脑与认知科学 Brain and Congition

尽管特定的大脑区域负责某项独立的功能，但这些区域组成的网络以及它们之间的连接才是人类表现出的整体行为的原因

人工智能中的联结主义(connectionist)： 通过模拟人类大脑中神经元的网络来处理信号，信号通过类似于 神经元间的连接方式从一个节点传递到另一个节点

一、脑科学基础与神经系统概述

1. 脑科学发展史

• 脑科学的诞生

  • Thomas Willis是临床神经科学创始人之一（1650年）
  • 脑科学发展早期的重要研究历史回顾

• 脑科学的历史争论

  • 定位主义：大脑的特定功能由特定脑区负责
    • 颅相学（19世纪）代表思想
    • Broca语言区和Wernicke感觉语言中枢的发现
    • Brodmann脑区划分系统的建立
  • 整体主义：大脑作为一个整体参与行为
    • 聚集场理论
    • 实验证据：切除大脑半球的鸽子实验

• 神经元研究的里程碑

  • Camillo Golgi和Santiago Ramon Cajal的贡献
  • 两人因对神经系统构造的研究共同获得1906年诺贝尔生理医学奖
  • 神经元学说的确立

• 现代脑科学的整合观点

  • "特定大脑区域负责特定功能，但区域间的网络和连接才是整体行为的基础"
  • 与人工智能中的联结主义(connectionism)关系
    • 通过模拟神经元网络处理信号
    • 信号通过类似神经元连接方式传递

2. 神经系统的细胞构成

• 神经元(Neuron)

  • 功能：基本的信息传递和处理单位
  • 特性：具有独特形态和生理学特性，专门进行信息传递和加工

• 神经胶质细胞(Neuroglial Cell)

  • 功能：非神经元细胞，承担多种辅助功能
    • 为神经元提供结构支持
    • 保证神经元间信息传递效率
  • 类型：
    • 星形胶质细胞：构成血脑屏障，保护中枢神经系统
    • 小胶质细胞：在脑组织损伤时发挥作用
    • 少突胶质细胞和许旺氏细胞：形成髓鞘，改变神经元内信息传递方式

• 髓鞘与神经疾病

3. 神经元的结构与形态

• 神经元的基本结构

• 细胞体：包含维持神经元新陈代谢的细胞器

• 树突(Dendrite)：

  • 接收其他神经元的传入信息
  • 接收部位是突触(Synapse)，被称为突触后(Post-synaptic)

• 轴突(Axon)：

  • 远离细胞体，将信息传出神经元
  • 被称为突触前(Pre-synaptic)

• 树突的特殊结构

  • 棘(Spine)：树突表面的球状突起
    • 突触通常位于这些棘上
    • 也存在于细胞体等其他部位

树突和轴突的形态关系： 突触并非随机地、均匀地分布在树突的各个部位，而是遵循特定的模式和规律。

• 神经元的分类与形态

  • 根据树突和轴突形态分类：
    • 单极神经元：只有一个远离细胞体的突起，该突起能分支形成树突和轴突，常见于无脊椎动物的神经系统。
    • 双极神经元：通过树突接收来自一端的信息，并通过轴突传至另一端，多参与感觉信息传递与加工。
    • 假单极神经元：树突和轴突融合的双极神经元，将躯体感觉信息传递到中枢神经系统。
    • 多极神经元：参与运动和感觉信息传递与加工，在于神经系统的多个区域，如人脑内的神经元

• 形态与功能关系：
  • 形态学相似的神经元倾向于集中在神经系统的某一特定区域。
  • 具有相似功能的神经元通常形态相似

4. 神经元的信息传递

神经元是神经系统传递信息的功能单位，通过对信息的接收和加工，并将其传递给其他神经元，构成了局部或长程的神经回路(circuit)。

• 信息传递的基本过程

  1. 信息接收：
     • 化学信号：神经递质(多巴胺、乙酰胆碱等)、环境化学成分
     • 物理信号：触觉/视觉信号等
  2. 动作电位产生：
     • 传入信号引起突触后神经元细胞膜去极化
     • 在轴突起始段产生动作电位(锋电位)
  3. 动作电位传递：
     • 沿轴突下行传播到轴突末梢
  4. 神经递质释放：
     • 突触释放神经递质，将信息传递到其他神经元

• 动作电位的研究

  • Alan Hodgkin和Andrew Huxley的研究
  • 1963年诺贝尔医学生理学奖得主
  • 电压钳技术的应用

• 神经元信息编码与人工智能

  • 神经元的发放率编码方式具有稀疏性特点：当外界刺激输入时，只有极少数与该刺激高度相关的神经元会以较高的发放率激活，而绝大多数神经元发放率极低甚至完全不发放，呈现 “少部分活跃，大部分静息” 的分布状态 —— 这就是 “稀疏性”。
  • 对人工神经网络激活函数的启示：
    • ReLU激活函数模仿神经元的稀疏性
    • 解决sigmoid函数在深层网络中的梯度消失问题

5. 神经元间的信息传递

• 突触的类型

  • 化学突触：通过神经递质传递信息
  • 电突触：通过缝隙连接直接传递电信号

• 化学突触的信息传递过程

  1. 动作电位到达轴突末梢
  2. 引起末梢去极化，导致Ca²⁺流入末梢
  3. 信息编码为不同类型的神经递质分子(>100种)，释放至突触间隙
  4. 神经递质扩散至突触后膜，引起突触后神经元的去极化或超极化

• 电突触的特点

  • 适用于快速传导信息的情况
  • 通过缝隙连接(gap junction)形成穿膜孔道
  • 缺点：不能传递抑制性信息，也不能放大信号

6. 神经回路

• 神经回路的基本概念

  • 定义：相互连接、共同实现某一特定功能的神经元集合
  • 神经元类型：
    • 兴奋性神经元：引起突触后神经元更容易产生动作电位
    • 抑制性神经元：引起突触后神经元更难产生动作电位

• 神经回路的实例：膝跳反射

  • 基本回路：
    • 感觉神经元将力学刺激转化为电信号
    • 感觉神经元与运动神经元形成突触连接
    • 运动神经元引起伸肌收缩
  • 协调机制：
    • 感觉神经元激活抑制性中间神经元
    • 抑制性神经元抑制支配屈肌的运动神经元
    • 伸肌收缩与屈肌放松相互协调

- ### 神经回路的复杂性 - 感觉信息可上行至大脑皮质多个区域 - 如初级躯体感觉皮质区和初级运动皮质 - 脊髓反射与大脑控制共同作用

7. 神经回路的基本模式

• 仅含兴奋性神经元的回路模体

  • 收敛式兴奋(Convergent Excitation)：
    • 多个突触前神经元与同一个突触后神经元形成突触
    • 接收、整合多个神经元的输入信息
  • 发散式兴奋(Divergent Excitation)：
    • 一个突触前神经元与多个突触后神经元形成突触
    • 同时向多个神经元传递信息
  
  • 前馈兴奋(Feedforward Excitation)：
    • 由连续连接的一组神经元构成
    • 跨多个脑区进行信息传递
  • 反馈兴奋(Feedback Excitation)：
    • 突触后神经元与突触前神经元建立反向突触连接
  • 复发性兴奋(侧兴奋)回路：
    • 并行传递同一信息的神经元之间相互激活
  

• 含兴奋性和抑制性神经元的回路模体

  • 前馈抑制(Feedforward Inhibition)：
    • 一个兴奋性神经元同时与一个兴奋性和一个抑制性神经元形成突触
    • 抑制性神经元将输出传递到突触后兴奋性神经元
  • 反馈抑制回路：
    • 突触后兴奋性神经元激活一个抑制性神经元
    • 抑制性神经元将抑制信号作用于前者
  
  • 复发性/交叉抑制(Recurrent/Cross Inhibition)：
    • 两条兴奋性并行通路通过抑制性神经元相互抑制
  • 侧抑制(Lateral Inhibition)：
    • 常见于感觉信息处理
    • 一个抑制性神经元接收并行兴奋性通路的输入，抑制这些通路的突触后神经元
  • 去抑制(Disinhibition)：
    • 一个抑制性神经元将信号输出至另一个抑制性神经元
    • 降低后者抑制目标的能力
  

8. 神经回路中的信号处理机制

• 输入突触的空间分布

  • 兴奋性神经元：输入突触主要位于树突棘上
  • 抑制性神经元：输入突触位于树突棘、树突轴、细胞体和轴突起始段
  • 调节性神经元：输入突触分别位于树突、细胞体及突触前末梢

• 突触输入的空间特性

  • 细胞体上的突触输入产生最大的兴奋性突触后电压
  • 距离细胞体越远，突触后电压越小，上升和衰减速度越慢

• 突触输入信号整合方式

  • 空间整合(Spatial Integration)：
    • 同一神经元两个不同树突几乎同时接收两个突触输入
    • 在传递过程中进行整合
  • 时间整合(Temporal Integration)：
    • 同一突触先后两次接收到两个输入
    • 在传递过程中进行整合

总结与作业 1

• 总结

  • 每个神经元是复杂的集成元件，接收多种输入信号
  • 神经元通过动作电位的发放频率和时间编码信息
  • 神经元作为复杂网络的元件，实现感知和行为控制等功能

• 作业

  • 题目1：分析神经元与感知机模型的异同
    • 参考资料：《机器学习》第五章"神经网络"，周志华著
  • 题目2：分析深度神经网络中存在的神经回路模体
    • 参考资料同上

二、人脑的基本结构和功能

1. 大脑结构与功能研究

• 研究意义与视角

  • 不适定问题：人脑与电脑的异同
  • 案例分析：爱因斯坦大脑的研究
    • 1985年研究发现左脑39区角回处神经胶质细胞与神经元比高出73%
    • 1996年研究发现右侧前额叶皮质较薄，神经元密度更大
    • 1999年研究发现顶叶(负责数学能力和空间推理区域)比普通人大15%

• 研究层面

  • 微观层面：精细解剖学
    • 研究神经元甚至亚细胞结构之间的组织关联
  • 宏观层面：大体解剖学
    • 用肉眼可区分的整体结构及其关联

2. 神经系统的基本构成

• 中枢神经系统

  • 组成：脑和脊髓
  • 功能：神经系统中进行命令和控制的部分

• 周围神经系统

  • 功能：负责传递信息的神经系统其余部分

• 人脑的解剖学定位术语

  • 标准化的解剖学定位描述系统（嘴侧，尾侧，背侧，腹侧）

3. 大脑的解剖学分区

• 脑叶划分

  • 额叶(Frontal Lobe)：与运动控制、决策和规划相关
  • 顶叶(Parietal Lobe)：与躯体感觉、空间感知相关
  • 颞叶(Temporal Lobe)：与听觉、语言处理和部分记忆相关
  • 枕叶(Occipital Lobe)：与视觉处理相关
  • 胼胝体(Corpus Callosum)：连接左右大脑半球的神经束

• Brodmann分区：
  • 按细胞形态和组织结构划分
  • 与功能分区不完全重合(如第17区与初级视皮层V1区重合，第18区与V2区不重合)

4. 大脑皮质的结构与功能

• 大脑皮质的基本特征

  • 沟回结构：增加皮质总面积，便于形成紧密的三维联系
  • 灰质与白质：
    • 灰质：皮质部分，含神经元细胞体、树突和部分轴突
    • 白质：皮质下的神经束，主要由轴突构成

• 大脑皮质的规模与连接

  • 包含约300亿个神经元
  • 每个神经元产生约1万个突触
  • 总连接数可达3×10¹⁴个
  • 微观结构模式相对统一，可能采用通用计算模式

• 大脑皮质的分层模式

  • 新皮质(Neocortex)：
    • 占大脑皮质的90%
    • 由6层细胞构成，包括感觉皮质、运动皮质和联合皮质
  • 中间皮质：
    • 也由6层神经元构成
    • 包括扣带回、海马旁回等边缘系统中的皮质
  • 异质皮质：
    • 仅含1-4层神经元
    • 包括海马、初级嗅皮质等

5. 大脑皮质的功能系统

• 感觉和运动皮质

  • 额叶中的运动区：
    • 初级运动皮质位于额叶后部
    • 前侧和腹侧是次级运动皮质(运动前区、辅助运动区、Broca区)

- **顶叶中的躯体感觉区**： - 接受来自丘脑的躯体感觉输入 - 处理触觉、痛觉、温度和本体感觉 - **枕叶中的视觉加工区**： - 初级视觉皮质(V1区)位于大脑半球内侧 - 处理颜色、亮度、空间频率、朝向及运动等信息 - **颞叶中的听觉加工区**： - 听觉信号经丘脑内侧膝状体到达颞叶上部听觉皮质 - **感觉和运动皮质的拓扑图**： - 身体和大脑皮质之间存在空间拓扑关系

• 联合皮质

  • 定义：新皮质中不能单纯划分为感觉或运动的部分
  • 特点：接收多个皮质区域的输入信息，神经元被多种感觉信息激活
  • 进化特点：哺乳动物从鼠到猫、猴和人的进化过程中，脑特别是新皮质的面积增加，其中联合皮质的占比在所有哺乳动物中最大。
  • 前额叶皮质：
    • 属于联合皮质，占额叶皮质的一半
    • 与几乎所有大脑皮质存在直接或间接联结
    • 在目标计划、执行和记忆等认知过程中发挥重要作用
    • 中国科大研究发现：内侧前额叶的CRF神经元决定"战斗或逃跑"反应，内侧前额叶的促肾上腺皮质激素释放激素（CRF）神经元是决定选择“战斗或逃跑”的关键，CRF神经元为一种抑制性的中间神经元，并与椎体神经元构成神经回路，CRF神经元的激活则促进主动应对的“战斗”行为，个体抗压能力增强。CRF神经元的失活则促进被动应对的“逃跑”行为，个体抗压能力减弱。

6. 边缘系统

边缘系统(limbic system)也称边缘叶，包括以下区域：扣带回(cingulate gyrus)，海马(hippocampus)，海马旁回(parahippocampalgyrus)，丘脑(thalamus)，下丘脑(hypothalamus)，杏仁核(amygdala)。

• 组成结构

  • 扣带回(Cingulate Gyrus)
  • 海马(Hippocampus)：在记忆和学习方面有重要作用
    • 位于颞叶腹内侧，属于异质皮质，仅由3-4层 神经元构成
    • 可分为CA1-CA4区
  • 海马旁回(Parahippocampal Gyrus)
  • 丘脑(Thalamus)：丘脑(thalamus) 包括外侧膝状体、内侧膝状体、腹后侧核团等。丘脑被称为“皮质的关口”，除了嗅觉输入以外，其余感觉通道的信息都需要经过丘脑中的相应区域后到达初级感觉皮质。

- 视觉：视网膜神经元→外侧膝状体→初级视皮质。听觉：内耳听觉神经元→内侧膝状体→初级。听皮质躯体感觉：躯体感觉：神经元→腹后侧核团→初级躯体感觉皮质 - 丘脑不仅是感觉信息输入大脑的中继站，还接收大量来自**相同皮质区域的输入信息皮质的关口** - 除嗅觉外，其余感觉信息需经丘脑到达初级感觉皮质 - 是感觉信息中继站，也接收来自皮质的反馈信息

• 下丘脑(Hypothalamus)：

  • 调节神经系统和内分泌系统
  • 参与情绪过程并控制垂体
  • 调节生理周期节律，通过激素释放进行远距离神经调控

• 杏仁核(Amygdala)：参与情绪处理

• 功能

  • 参与情绪、学习和记忆的加工

7. 其他重要脑区

• 基底神经节

  • 组成：皮质下多个神经组织的集合
  • 功能：在运动控制中起重要作用
  • 特点：不直接控制运动，而是参与监控运动活动进程
  

• 脑干

  • 组成：中脑(Midbrain)、脑桥(Pons)和延髓(Medulla)
  • 功能：控制呼吸、睡眠和觉醒等基本生命活动
  • 特点：损伤大多致命，而皮质损伤相对影响较小

• 小脑

  • 位置：覆盖于脑干上部，处于脑桥水平位置
  • 规模：约110亿神经元，与中枢神经系统其余部分相当
  • 功能：
    • 参与运动和感觉信息加工
    • 整合身体和运动信息并调整运动
    • 维持姿态、行走以及协调运动，使其变得流畅而协调
  

• 脊髓

  • 组成：
    • 后角内的感觉神经元：从外周感受器接收感觉信息并传导到大脑皮质
    • 前角内的运动神经元：将大脑产生的运动控制信息传递到相应的肌肉组织
  • 

8. 神经系统的运动控制

• 运动控制系统

  • 运动系统：控制骨骼肌实现人体运动(如伸手抓握、行走、说话)
  • 自主神经系统：控制平滑肌和心肌收缩，调控内脏功能
  • 神经内分泌系统：分泌激素调节生理和行为(如对食物及光线周期的反应)

• 运动控制的分层组织

  • 最高层：大脑皮质(运动相关区域)
    • 处理感觉输入信息
    • 计划和执行运动目标
  • 中间层：小脑和基底神经节
    • 辅助运动皮质和脑干
  • 底层：脊髓
    • 包含神经回路(如膝跳反射)
    • 感觉和运动神经元
    • 在骨骼肌内的神经末梢

• 信息流动特点

  • 分布式控制：跨越不同层级的控制系统
  • 层级化结构：
    • 高层神经系统不关心运动细节，控制低层级神经系统
    • 低层级将运动控制信息转变成具体动作
  • 灵活性：同一感觉输入可产生多种不同运动方式

• 作业2

  • 题目1：分析司机遇到动物挡路时神经系统的工作过程
    • 信息流动顺序
    • 相关信息处理加工的神经系统组织结构
  • 题目2：设计无人驾驶车辆人工智能系统的层级化基本功能结构

三、大脑半球特异化

1. 大脑半球功能特异化现象概述

• 基本特征

  • 左右大脑半球在整体结构和功能上高度相似
  • 在少数特定功能上存在明显特异性

• 利手现象

  • 惯用右手：左侧大脑半球控制（人群中占大多数）
  • 惯用左手：右侧大脑半球控制（人群中占比7%-8%）
  • 左撇子与右撇子的智力比较无显著差异

• 语言处理的优势半球

  • 左侧大脑半球在语言信息处理中占据主导地位
  • Broca将语言机制定位在左侧大脑半球
  • 现代研究数据：
    • 约96%的右利手者主要依靠左侧大脑半球进行语言处理
    • 约60%的左利手者也主要依靠左侧大脑半球进行语言处理

2. 大脑半球的结构差异

• 宏观结构差异

  • 右利手者的左侧大脑半球颞叶Wernicke区面积相对右侧较大
  • 微观结构差异：左侧颞叶Wernicke区皮质柱间距相对较大，可能导致局部信息流更具独立性

3. 裂脑人研究与半球功能特异化

• 胼胝体的结构与功能

  • 结构：连接左右大脑半球皮质，包含超过2亿条神经纤维
  • 连接模式：
    • 多数神经纤维连接左右半球等位区域
    • 少数神经纤维连接左右半球异位区域
  • 功能假说：
    • 抑制性：两侧大脑半球通过胼胝体相互抑制，竞争信息处理控制权
    • 激活性：两侧大脑半球通过胼胝体整合不同输入信息，促进信息处理

• 裂脑人实验

  • 历史背景：癫痫治疗中胼胝体切断手术，形成"裂脑人"
  • 斯佩里的研究：20世纪60年代开始，获1981年诺贝尔医学与生理学奖
  • 实验设计：控制感知范围，使单侧大脑半球获得感觉信息输入
  • 关键发现：
    • 现象1：裂脑人可以用语言确认右眼输入的视觉信息（进入左脑）
    • 现象2：裂脑人无法用语言确认左眼输入的视觉信息（进入右脑）
    • 现象3：裂脑人可以通过左手动作确认左眼输入的视觉信息（右脑具有物体辨识能力）

• 胼胝体功能的精确研究

  • 胼胝体后部切断：无法传递感觉信息
  • 胼胝体前部完整：可传递高级语义信息
  • 胼胝体前部切断：无法传递高级语义信息
  • 胼胝体完整：可传递感觉信息

4. 左右大脑半球的特异化能力

• 左侧大脑半球的特异化能力

  • 语言信息处理能力
  • 逻辑推理能力
  • 证据：
    • 双耳分听实验：报告听到的单词中，绝大部分都是右耳听到的
    • 右脑并非完全不具备语言能力，少数裂脑人的右脑存在一定语言能力

• 右侧大脑半球的特异化能力

  • 空间信息的处理能力
  • 对陌生人脸的识别能力
  • 语言中的情绪信息处理
  • 证据：
    • 坐标空间关系判断：右脑更擅长精确、定量的空间关系
    • 范畴空间关系判断：左脑更擅长抽象、定性的空间关系
    • 脑损伤研究：右脑损伤病人在坐标空间关系判断中更容易出错

5. 左右脑分工理论

• 斯佩里的左脑右脑分工理论

  • 左脑：擅长语言、逻辑、计算和分析
  • 右脑：擅长空间、音乐、直觉
  • 应用解释：
    • 右脑在探测物体时空关系的因果感知方面有优势
    • 左脑在利用逻辑规则和概念知识进行因果推理方面有优势

6. 大脑半球特异化的原因

• 胼胝体功能假说

  • 抑制性假说：两侧大脑半球通过胼胝体相互抑制
  • 激活性假说：两侧大脑半球通过胼胝体整合信息

• 大脑半球相互激活面临的问题

  • 信息处理一致性：
    • 两侧大脑半球的输入信息随时间变化具有独立性
    • 跨半球信息整合困难
    • 神经元信息处理速度较慢，跨半球传递时间约30毫秒
    • 语言交流、快速动作等时间敏感性任务难以采用跨半球处理方式
  • 输出控制一致性：
    • 不能允许两个半球分别控制不同行为
    • 将输出功能集中于某一侧半球可实现输出一致性
  • 利手与语言同侧优势的原因：
    • 左侧大脑半球擅长对发声韧带、舌头等发音器官的连续动作控制
    • 左侧大脑半球更擅长对左右单手连续动作的控制

• 生成装配器(GAD)假说

  • 大脑中某个单侧半球（大多数情况下在左侧）进化出从基本元素中产生复杂连续表征的装置
  • 实现以生成式认知为主的行为和思考模式

7. 大脑半球在其他功能上的特异化

• 视觉信息处理特异化

  • 层级化表征：视觉信息在大脑中被层级化表征
  • 特异化能力：
    • 左脑：更擅长提取局部视觉信息
    • 右脑：更擅长提取整体视觉信息
  • 空间频率假说：
    • 视觉系统由空间滤波器构成
    • 右脑：低通滤波器优势，擅长提取整体信息
    • 左脑：高通滤波器优势，擅长提取局部信息
  • 应用实例：
    • 右脑对基于视觉的性别判断有优势（低频整体信息）
    • 左脑对基于视觉的熟悉人脸识别有优势（高频细节信息）

• 记忆表征特异化

  • 两种记忆表征方式：
    • 抽象、范畴化的原型记忆
    • 具体、特例化的样例记忆
  • 半球特异化：
    • 左脑：更擅长抽象、范畴化的原型记忆
    • 右脑：更擅长具体、特例化的样例记忆
  • 实验证据：左脑更快识别出原型，右脑更快识别出学习过的样例

• 情感信息处理特异化

  • 前额叶皮质的特异化：
    • 左侧前额叶：更擅长处理积极情感
    • 右侧前额叶：更擅长处理消极情感
  • 损伤后果：
    • 左脑损伤可能导致抑郁
    • 右脑损伤可能导致狂躁
  • 社交行为差异：
    • 左脑：社交场合的主动接近
    • 右脑：社交场合的被动逃避

• 概率决策特异化

  • 决策策略差异：
    • 左脑：频率匹配策略
    • 右脑：期望最大化策略
  • 赌徒谬论：左脑更容易出现"赌徒谬误"
  • 解释器(Interpreter)假说：
    • 左脑中存在特殊认知系统，尝试为观察现象寻找解释
    • 负责建构理论，试图解释现象以更有效处理，但可能对决策产生负面影响
    • 右脑不参与此过程，对简单现象决策可能更准确
  • 联合决策：两侧半球通过胼胝体整合信息形成更鲁棒的决策

8. 人工智能技术中的生成模型

• 生成模型概述

  • 应用领域：自然语言处理、语音合成、图像合成、服务型机器人等
  • 模型类型：
    • 隐Markov模型(HMM)
    • 循环神经网络(RNN)/长短时记忆网络(LSTM)
    • 生成式对抗网络(GAN)
  • 核心理念："What I cannot create, I do not understand" – 费曼

• 循环神经网络(RNN)特点

  • 隐藏层之间的节点存在连接
  • 隐藏层的输入包括输入层的输入和上一时刻隐藏层的输出
  • 网络对以前信息进行记忆并应用于当前输出计算

• 人类语言的生成能力：

  • 左脑生成的复杂语言示例：
    • "今天下雨，我骑车差点摔倒，好在我一把把把把住了！"
    • "用毒毒毒蛇毒蛇会不会被毒毒死?"
    • "多亏跑了两步，差点没上上上上海的车!"
    • "校长说：校服上除了校徽别别别的，让你们别别别的别别别的你非别别的！"
    • "来到杨过曾经生活的地方，小龙女动情地说：我也想过过过儿过过的生活!"

9. 总结与反思

• 大脑半球特异化的基本特征

  • 左右半球在整体结构和功能高度相似
  • 在特定功能上存在明显特异化

• 半球协作与分工模式：

  • 对于大多数任务，左右半球都能完成相应信息处理（方式可能特异化）
  • 通过胼胝体对信息进行整合
  • 对于语言等时间敏感性任务，由单侧大脑半球独立完成

• 科学认识大脑半球差异：

  • 将大脑半球差异绝对化的观点（如"左脑语言、右脑空间"，"左脑分析、右脑整体"）是不科学的
  • 大脑半球特异化是复杂的神经科学现象，需要全面、辩证地理解

四、感觉和知觉

1. 知觉的概念与基本特征

• 知觉的定义

  • 知觉是一系列组织并解释外界事物的感觉信息加工过程
  • 包括视觉、听觉、躯体感觉、嗅觉和味觉五种感觉

• 感觉与知觉的联系与区别

  • 联系：
    • 都由事物作用于感觉器官产生
    • 知觉的产生以感觉信息为前提
    • 与感觉同时进行，一种感觉信息可引起对物体的知觉
  • 区别：
    • 感觉是对客观事物个别属性的认识
    • 知觉是对事物整体的认识，通过多种感觉结合形成
    • 感觉不依赖个人知识和经验，知觉受个人知识经验影响

• 感觉与知觉在认知过程中的地位

  • 是人类认识世界的初级形式
  • 需在感觉、知觉基础上进行更复杂的心理活动（记忆、想象、思维等）

2. 嗅觉系统与处理

• 嗅觉的基本特征

  • 最古老的感觉信息，占人体全部编码基因的3%
  • 基本功能：闻到食物、感受环境状况、感知危险
  • 嗅觉皮质与情绪、恐惧、记忆、快乐等情感皮质区域相同
  • 在社交能力方面扮演重要作用

• 嗅觉的神经通路

  • 感受器：鼻粘膜中有超过1000种感受器（双极神经元）
  • 信息传递：嗅感受器→嗅球中的嗅小体→初级嗅皮质→次级嗅皮质
  • 功能特异化：
    • 初级嗅皮质与探测气味变化相关
    • 次级嗅皮质与分辨气味类型相关

• 嗅觉信息的神经回路

  • 三种可能结构：
    1. 同种气味感受器的细胞体在鼻腔内空间聚集，轴突发送到同一嗅小体
    2. 同种气味感受器的细胞体在鼻腔内空间分散，但轴突发送到同一嗅小体
    3. 同种气味感受器的细胞体在鼻腔内空间分散，轴突发送到多个嗅小体
  • 侧抑制神经回路：
    • 由兴奋性神经元和抑制性神经元构成
    • 功能：提高气体分辨率、增益控制、控制动作电位时间间隔
  

• 嗅觉处理的特异化现象

  • 左右鼻孔大小随时间交替变化
  • 高流速鼻孔对高吸收率气味分子更敏感
  • 低流速鼻孔对低吸收率气味分子更敏感
  • 具有不同气流速度的感受系统可同时感知不同吸收率的气味分子

• 气味与记忆的关系

  • 原因：嗅皮质与边缘系统直接连接
  • 边缘系统是记忆和情绪的主要区域
  • 海马损伤病人的气味识别能力严重受损

3. 味觉系统

• 味觉的基本特征

  • 人口腔中有约10000个味蕾，大部分位于舌头
  • 基本味觉信息：
    • 咸：矿物质/电解质与水的平衡信息
    • 甜：碳水化合物（能量）
    • 鲜：蛋白质
    • 苦/酸：进化产生的警告信号
    • 辣味不是味觉，而是痛觉信息

• 味觉信息的神经通路

  • 味觉神经元→丘脑中的腹后内侧核→初级味觉皮质→次级味觉皮质（眶额皮质）

4. 躯体感觉系统

• 躯体感觉的类型与感受器

  • 触觉信息：
    • 一般触觉：梅克尔小体
    • 轻微触觉：迈斯纳小体
    • 深部压力：环层小体
  • 温度信息：鲁菲尼小体
  • 痛觉信息：疼痛感受器（有髓鞘：快速反应；无髓鞘：持续疼痛）
  • 本体感觉信息：肌肉-肌腱连接处的特化神经元

• 躯体感觉的神经通路

  • 感受器→脊髓→脑干→对侧丘脑→初级躯体感觉皮质（S1）→次级躯体感觉皮质（S2）→小脑

• 躯体感觉皮质的特征

  • 初级躯体感觉皮质的面积取决于相应感觉信息的重要性
  • 次级躯体感觉皮质可编码更复杂的物体纹理和大小信息

5. 听觉系统

• 听觉的基本功能

  • 对环境的感知
  • 同类间的识别交流
  

• 听觉的物理与神经转换

  • 声波→耳鼓振动→内耳液体振荡→耳蜗毛细胞（机械信号转换为动作电位）
  • 听觉信息→听神经→丘脑内侧膝状体→初级听觉皮质

• 听觉信号的频率编码

  • 人类听觉范围：20Hz-20000Hz，对1000Hz-4000Hz最为敏感
  • 编码机制：
    • 低频信号：动作电位在每个周期都发放
    • 高频信号：单个神经元仅在部分周期内发放
  • 联合编码：依赖多个神经元的联合编码
  • 频率激活空间模式：听觉区具有特定的频率激活空间模式

• 基于听觉的空间定位

  • 双耳信息整合：
    • 耳间时差：声音到达两耳的先后顺序和间隔时间
    • 耳间强差：声音在两耳分别产生的信号强度不同

• 听觉定位的神经编码模型

  • 耳间时差检测（水平方向）：
    • 时间同步编码
    • 存在同步检测器神经元，只有两耳信号同时输入才能被激活
    • 声源位于正前方时，正中的同步检测器被激活
    • 声源位于一侧时，偏离中心的同步检测器被激活
  • 耳间强度检测（垂直方向）：
    • 信号强度编码
    • 强度由神经元发放频率编码
    • 下游神经元结合双耳信号的发放频率差异，确定竖直位置
  • 特点：
    • 空间信息编码：水平方向为时间同步编码，垂直方向为信号强度编码
    • 分布式处理：分别处理时差和强差信息再进行整合
    • 定位系统位于脑干中，仅解决"在哪里"问题

6. 视觉系统

• 视觉的基本功能

  • 从背景中分辨物体
  • 定位感兴趣的对象
  • 检测运动以及在环境中定向

• 视网膜上的感光神经元

  • 视杆细胞：
    • 分布在整个视网膜上
    • 感受低光刺激，夜间工作
    • 无法区分颜色，产生低精度视觉，响应慢
  • 视锥细胞：
    • 集中在中央凹
    • 感受强光刺激，白天工作
    • 对不同颜色敏感，产生高精度视觉，响应快
  • 视锥细胞类型：
    • 蓝色、绿色和红色三种视锥细胞
    • 人类视觉对长波光更敏锐，绿色和红色视锥细胞占绝大多数
    • 蓝色视锥细胞占比较小
    • 红色或绿色视锥细胞功能异常导致色盲

• 视网膜上的视觉信息处理

  • 感光细胞将光信号转化为电信号
  • 需要提取有效特征（运动、深度、形状、大小、颜色等）
  • 系统选择保留有价值信息，删除不相关信息

• 视网膜神经元的感受野

  • 感受野定义：视觉神经元仅对有限空间区域的光信号产生反应的区域
  • 中心-外周类型感受野：
    • 可被光斑信号激活
    • 分为：
      • 中心兴奋-外周抑制型
      • 中心抑制-外周兴奋型
  • 侧抑制神经回路：
    • 放大激活和未激活感光细胞间的兴奋性差异
    • 提升平行输入信号间的差异，提高信噪比
  • 视觉意义：
    • 可感知局部区域中的明暗对比，确定光信号的空间信息
    • 解释视错觉现象（赫曼方格、马赫带等）

• 视网膜神经元的多样性

  • 除中心-外周感受野神经元外，还有大量其他类型神经元
  • 形成复杂神经回路，处理对比度、大小、运动状态和颜色等信息
  • 方向选择性神经元对特定方向的刺激有更强响应

• 视觉信息传递的视神经通路

  • 视交叉：视神经颞侧分支同侧传递，鼻侧分支交叉到对侧
  • 两条主要通路：
    • 主要通路（~90%）：视网膜→丘脑外侧膝状体→初级视皮质
    • 次要通路（~10%）：视网膜→皮质下结构（丘脑枕核、中脑上丘等）
  • 功能特异化：
    • P通路（小细胞层）：传递高敏锐度和色觉信息
    • M通路（大细胞层）：传递亮度信息，具有良好对比和时间分辨率

• 初级视皮层神经元的感受野

  • 简单细胞：
    • 具有中心兴奋-外周抑制的条状感受野
    • 可被特定方向的光条激活
    • 功能：检测图像中的线条和轮廓
  • 复杂细胞：
    • 感受野更大、更复杂，无具体激活-抑制区域
    • 可被任何位置上特定方向的光条激活
    • 功能：进一步整合空间信息，识别感受野中所有线条/轮廓

• 视觉信息处理的层级模型

  • 前馈模型假说：
    • 外侧膝状体神经元感受野线性排列组成简单细胞感受野
    • 相邻区域同向排列的简单细胞感受野组合形成复杂细胞感受野
    • 视觉通路由层级化的前馈计算模型构成，提取重要视觉信息

• 初级视皮质柱内的神经回路

  • 两个组织原则：
    • 视网膜拓扑学映射：视皮质特定部位接收来自视网膜对应部位的信息
    • 功能架构：具有相同特性的神经元排在垂直于皮质表面的轴上
  • 皮质柱结构：
    • 视皮质分为6层，皮质柱内神经环路大致为LGN→L4→L2/3→L5→L6
    • 同一皮质柱内神经元具有相似功能特性
  

7. 视觉信息的分布式处理

• 视觉信息分布式处理假说

  • 大脑对视觉信息处理具有分布式特点
  • 不同视皮质区域分别形成颜色、运动等知觉，再整合形成全面感知
  • 功能特化的视觉区域：
    • V1（初级视皮质）：简单视觉处理
    • V2：图形与物体形状处理
    • V3：视觉信息传递
    • V4：颜色和形状知觉
    • MT（中颞区，V5）：运动知觉
• 

• MT区与运动知觉

  • MT区神经元特点：
    • 被运动信号激活，对颜色不敏感
    • 朝向特定方向运动时兴奋性最强
    • 神经元兴奋性与运动速度有关
  • MT区损伤的影响：
    • 单侧MT区损伤对运动知觉影响较小
    • 双侧MT区损伤导致运动知觉丧失

• V4区与颜色知觉

  • 脑功能成像研究：
    • 运动视觉信息导致MT区激活
    • 颜色视觉信息导致V4区激活
  • 全色盲：
    • 由中枢神经系统（V4区为主）损伤引起
    • 症状为对所有颜色均无法形成知觉
    • 对深度和纹理知觉保持正常

• V4区与形状知觉

  • 颜色与形状的关系：
    • 颜色可提供物体形状的重要信息
    • V4区参与形状知觉，使用颜色信息确定物体形状
  • 艺术家与视觉处理：
    • 毕加索作品有明显阴影和轮廓
    • 莫奈作品缺少明显阴影和轮廓，依赖颜色表现形状
  • 形状盲：
    • 由于形状知觉来源于多种视觉信息
    • 完全丧失形状知觉的"形状盲"现象极为罕见

• 深度知觉

  • 信息来源：
    • 双眼视差
    • 运动遮挡
    • 物体在视网膜上成像的大小
  • 深度盲：由于深度知觉存在多种信息来源，完全丧失的"深度盲"现象极为罕见

• 视觉信息处理的皮质通路

  • 背侧通路/空间通路（where pathway）：
    • 功能：处理运动和深度信息
    • 输入：视神经M通路
    • 途径：V1→V2→V3→MT→顶叶皮质
  • 腹侧通路/内容通路（what pathway）：
    • 功能：处理形态和颜色信息
    • 输入：视神经M和P通路
    • 途径：V1→V2→V4→颞下皮质
  • 实际复杂性：
    • 有30多个皮质区域参与视觉信息处理
    • 形成包含300多个连接的高度复杂层级化网络

8. 多种感觉信息的整合

• 多感觉整合的意义

  • 形成对外界事物统一的多感觉表征
  • 使知觉更加准确、高效

• 多感觉整合的实例

  • 联合视觉、听觉和躯体感觉信息，使神经元兴奋性明显增强
  • 在嘈杂环境中交流时，注视对方面部动作可加强语言理解

• 多感觉整合的脑区

  • 颞叶、顶叶、额叶、海马等很多皮质区域均参与多种感觉信息的整合

9. 作业 3

• 题目1

  • 分析侧抑制产生的视网膜神经元中心-外周感受野原理
  • 解释马赫带视错觉现象的产生原因

• 题目2

  • 分析仿人机器人应模仿的至少两种人类感觉
  • 给出理由说明为什么这些感觉的模仿最为重要
  • 参考资料：《机器人时代》https://www.bilibili.com/bangumi/play/ss21850/

C语言学习框架

一、准备知识

1.1 C语言的历史

C 语言是一种通用的、面向过程式的计算机程序设计语言。
1972 年，为了移植与开发 UNIX 操作系统，丹尼斯·里奇在贝尔电话实验室设计开发了 C 语言。

1.2 编译和链接相关知识

常见的编译器msvc、clang、gcc

• GCC（GNU Compiler Collection）

  • 最广泛使用的开源编译器套件，支持 C、C++、Objective-C 等多种语言，适配几乎所有主流平台（Linux、Windows、macOS、嵌入式系统）。由 GNU 项目开发，是 Linux 系统的默认编译器。

• Clang

  • 开源编译器（基于 LLVM 架构），以编译速度快、错误提示清晰著称，兼容 GCC 的语法和大部分功能。Apple 的 Xcode 开发工具默认使用 Clang，也是许多开源项目（如 Chrome、LLVM）的首选编译器。

• MSVC（Microsoft Visual C++）

  • 微软开发的闭源编译器，仅支持 Windows 平台，集成在 Visual Studio 中。对 Windows 系统 API 和 C++ 标准的支持非常及时，适合开发 Windows 应用程序。

• Intel C++ Compiler

  • 英特尔针对自家 CPU 优化的编译器，在科学计算、高性能计算领域表现优异，兼容 GCC 和 MSVC 的语法。

集成开发环境 如：VS2022、XCode、CodeBlocks、DevC++、Clion

• VS2022 集成了MSVC（安装报包较⼤⼀些，安装简单，⽆需多余配置，使⽤起来⾮常⽅便）
• XCode 集成了clang（苹果电脑上的开发⼯具）
• CodeBlocks 集成了gcc（这个⼯具⽐较⼩众，需要配置环境，不太推荐）
• DevC++ 集成了gcc（⼩巧，但是⼯具过于简单，对于代码⻛格的养成不好，⼀些竞赛使⽤）
• Clion 是默认使⽤CMake，编译器是可以配置的（⼯具是收费，所以暂时推荐⼤家使⽤）

1.3 ASCLL码相关知识

+ 字符A~Z的ASCII码值从65~90 + 字符a~z的ASCII码值从97~122 + 对应的⼤⼩写字符(a和A)的ASCII码值的差值是**32** + 数字字符0~9的ASCII码值从48~57 + 换⾏ \n 的ASCII值是：10 + 在这些字符中ASCII码值从0~31 这32个字符是不可打印字符，⽆法打印在屏幕上观察

1.4 C语言实现过程

C语⾔是⼀⻔编译型计算机语⾔，C语⾔源代码都是文本文件，⽂本⽂件本⾝⽆法执⾏，必须通过编译器翻译和链接器的链接，⽣成⼆进制的可执行文件，可执⾏⽂件才能执⾏。

C语⾔代码是放在.c为后缀的⽂件中的，要得到最终运⾏的可执⾏程序，中间要经过编译和链接2个过程。

注： 1. 每个源⽂件(.c)单独经过编译器处理⽣成对应的⽬标⽂件(.obj为后缀的⽂件) 2. 多个⽬标⽂件和库⽂件经过链接器处理⽣成对应的可执⾏程序(.exe⽂件)

如果不借助IDE，如何把源代码保存在一个文件中，以及如何编译并运行它。下面是简单的步骤：

1. 打开一个文本编辑器，添加以下述代码。

#include <stdio.h>
int main()
{
    printf("hello world"\n);
    return 0;
}

1. 保存文件为 hello.c.
2. 打开命令提示符，进入到保存文件所在的目录.
3. 键入 gcc hello.c，输入回车，编译代码.
4. 如果代码中没有错误，命令提示符会跳到下一行，并生成 a.exe可执行文件.
5. 现在，键入 a.exe 来执行程序,可以看到屏幕上显示 "Hello World".

1.5 C语言程序结构

C 程序主要包括以下部分：

• 预处理器指令
• 函数
• 变量
• 语句 & 表达式
• 注释

二、C语言中的main()函数

所有的C语言程序都需要包含 main() 函数。 代码从 main() 函数开始执行.不可以随意更改主函数的名称,即main,main函数有且只有一个.

//标准主函数的写法
int main()
{
    printf("hello world"\n);
    return 0;
}

要点:

1. 其中int表示整型,当是 int main() 时，main() 的返回值是 int 类型，所以是 return 0; C 标准里规定 main() 返回值必须为 int，所以必须写成是 int main().
2. 当是 void main() 时，main() 的返回值是空，所以可以不写或者是 return; 但这是以前的写法，现在很少用 void main().
3. main后的括号中,可以加上void来明确告诉主函数没有参数,不需要参数.这个void可以省略.

int main(void)
{
    printf("hello world"\n);
    return 0;
}

细节:

1. printf() 用于格式化输出到屏幕。printf() 函数在 "stdio.h" 头文件中声明。
2. 使用printf()这个库函数,需要在代码的最前面加上头文件
3. return的值约定正常运行就输出0,不正常输出就输出非0数

#include <stdio.h>

1. stdio.h 是一个头文件 (标准输入输出头文件),表示系统文件库, 也可以声明其他的.
2. #include是一个预处理命令，用来引入头文件,即告诉预处理器将指定头文件的内容插入到预处理器命令的相应位,导入头文件的预编译指令.
3. <> 表示系统自带的库，也可以写成" "表示用户自定义的库 如果写成" "并且自定义的库里面没有这个文件系统会自动查找自带的库,如果还是没有报错.
4. std代表standard,i和o指数字输入和输出；.h是头文件(函数的声明,类型的声明,头文件的包含),因为这些文件都是放在程序各文件的开头；.c是源文件(函数的实现).

其他:
当编译器遇到 printf() 函数时，如果没有找到 stdio.h 头文件，会发生编译错误。如下：

warning: implicitly declaring library function 'printf' with type'int (const char *, ...)' [-Wimplicit-function-declaration]

1. 以上警告一般发生在没有包含头文件 #include <stdio.h> 就使用 printf 的情况
2. 这句话提示的意思是：用类型“int (const char *,...)”隐式声明了库函数printf。
3. 该提示的背景知识：因为 printf 这一类库函数太常用了，所以编译器在编译的时候，发现源文件中并没有声明 printf 这个函数就直接使用了它，那么编译器就会为 printf 函数隐式生成一个声明。你那个编译器提示你，它为printf生成的隐式声明是：int printf(const char *, ...)
4. 该提示后果：通常情况下，这个提示只是一个 warning，而不是 error，编译仍然可以通过。

三、C语言的数据类型

在 C 语言中，数据类型指的是用于声明不同类型的变量或函数的一个广泛的系统。变量的类型决定了变量存储占用的空间，以及如何解释存储的位模式。

C 中的类型可分为以下几种：

3.1 字符型

char字符数据类型

3.1.1 char是如何存储的

字符型（char）用于储存字符（character），如英文字母或标点。但是char类型在内存中并不是以字符的形式储存，而是以ASCII码的形式储存，也可以说char类型储存的实际上是整数。所以char类型也被归类为整形家族。

int main()
{
	char c = 'A';
	printf("%d\n", c);//会输出'65'
	printf("%c\n", c);//会输出A
	return 0;
}

既然知道char实际上是整形，所以也可以用int类型对char类型赋值

int main()
{
	int c = 65;//这里也可以是char c = 65；
	printf("%d\n", c);
	printf("%c\n", c);
	return 0;
}

结果完全一致，都是
65
A

3.1.2 char的类型

当听到char的类型这句话时，第一反应应该会是：“char类型不就是char嘛”
其实不然，char类型实际上分区为有符号的signed char和无符号的unsigned char

对于char的有无符号位比较特殊的是:

1. char与signed char不一定等价
2. char默认是signed char还是unsigned char取决于编译器
3. 在常见的编译器里，char类型都默认为signed char

3.1.3 int和char的辨析和比较

在C语言中，int和char是两种不同的数据类型，它们有以下区别：

1. 数据范围：int是整数类型，通常占用4个字节（32位），可以表示较大范围的整数，包括正数、负数和零。而char是字符类型，占用1个字节（8位），用于表示单个字符，包括字母、数字和特殊字符。

2. 存储方式：int类型的变量以二进制补码形式存储，可以进行算术运算。char类型的变量以ASCII码形式存储，可以表示各种字符。

3. 字面值表示：int类型的字面值可以直接写成整数形式，如10、-5等。char类型的字面值需要使用单引号括起来，如'a'、'1'等。

4. 内存占用：int类型通常占用的内存空间比char类型更大。在一些特殊情况下，char类型可以用来节省内存空间。

5. 运算操作：int类型可以进行各种算术运算，如加减乘除、取模等。char类型可以进行一些基本的字符操作，如比较、拼接等。

6. 数据表示：int类型的变量可以表示整数值，如年龄、成绩等。char类型的变量可以表示字符值，如姓名的首字母、键盘输入等。

（2）整型

• (char)字符型
• short短整型

short [int]
[signed] short [int]
unsigned short [int]

• int整型

int
[signed] int
unsigned int

• long长整型

long [int]
[signed] long [int]
unsigned long [int]

• long long更长的整型

long long [int]
[signed] long long [int]
unsigned long long [int]

• _Bool 布尔类型

C 语⾔原来并没有为布尔值单独设置⼀个类型，⽽是使⽤整数 0 表⽰假，⾮零值表⽰真。在 C99 中也引⼊了 布尔类型 ，是专⻔表⽰真假的。 布尔类型的使⽤得包含头⽂件 <stdbool.h> 布尔类型变量的取值是： true或者 false.

代码演示：

_Bool flag = true;
if (flag)
    printf("i like C\n");

（3）浮点型

float 单精度浮点数
double 双精度浮点数(精度更高) long double

*各种数据类型的⻓度

每⼀种数据类型都有⾃⼰的⻓度，使⽤不同的数据类型，能够创建出⻓度不同的变量，变量⻓度的不同，存储的数据范围就有所差异。

1.sizeof 操作符

sizeof 是⼀个关键字，也是操作符，专⻔是⽤来计算sizeof的操作符数的类型⻓度的，单位是字节。

sizeof( 类型 )
sizeof 表达式

注意点：

• sizeof 操作符的操作数可以是类型，也可是变量或者表达式。
• sizeof 的操作数如果不是类型，是表达式的时候，可以省略掉后边的括号的。
• sizeof 后边的表达式是不真实参与运算的，根据表达式的类型来得出⼤⼩。

2.sizeof的返回值

sizeof 的计算结果是 size_t 类型的。

sizeof 运算符的返回值，C 语⾔只规定是无符号整数，并没有规定具体的类型，⽽是留给系统⾃⼰去决定， sizeof 到底返回什么类型。不同的系统中，返回值的类型有可能是unsigned int ，也有可能是 unsigned long ，甚⾄是 unsigned long long ，对应的 printf() 占位符分别是 %u 、 %lu 和 %llu 。这样不利于程序的可移植性。C 语⾔提供了⼀个解决⽅法，创造了⼀个类型别名 size_t ，⽤来统⼀表⽰ sizeof 的返回值类型。对应当前系统的 sizeof 的返回值类型，可能是 unsigned int ，也可能是unsigned long long 。

#include <stdio.h>
int main()
{
   int a = 10;
   printf("%zd\n", sizeof(a));
   printf("%zd\n", sizeof a);//如果a是变量的名字，可以省略掉sizeof后边的()
   printf("%zd\n", sizeof(int));
   printf("%zd\n", sizeof(3 + 3.5));
   return 0;
}

结果是
4 4 4 8

3.数据类型长度

打印看看各个数据类型的所占空间

int main()
{
   printf("%zd\n",sizeof(char));
   printf("%zd\n",sizeof(_Bool));
   printf("%zd\n",sizeof(short));
   printf("%zd\n",sizeof(int));
   //在c语言中规定sizeof(long)>=sizeof(int)
   printf("%zd\n",sizeof(long));
   printf("%zd\n",sizeof(long long));
   printf("%zd\n",sizeof(float));
   printf("%zd\n",sizeof(double));
   printf("%zd\n",sizeof(long double));
   return 0;
}

结果是:
1 1 2 4 4 8 4 8 16 (单位:字节B)

4.表达式中sizeof不计算

#include <stdio.h>
int main()
{
   short s = 2;
   int b = 10;
   printf("%d\n", sizeof(s = b+1));
   printf("s = %d\n", s);
   return 0;
}

*signed 和 unsigned

1.两者区别

C 语⾔使⽤signed和unsigned关键字修饰字符型和整型类型的。

signed关键字，表⽰⼀个类型带有正负号，包含负值；
unsigned关键字，表⽰该类型不带有正负号，只能表⽰零和正整数。

对于int类型，默认是带有正负号的，也就是说int等同于signed int 。

2.unsigned的好处

整数变量声明为 unsigned 的好处是，同样⻓度的内存能够表⽰的最⼤整数值，增⼤了⼀倍。 ⽐如，16位的 signed short int 的取值范围是：-3276832767，最⼤是32767；⽽ unsigned short int 的取值范围是：065535，最⼤值增⼤到了65,535。32位的 signed int 的取值范围可以参看limits.h中给出的定义。

3.省略问题

• 由于这是默认情况，关键字 signed ⼀般都省略不写，但是写了也不算错。

signed int a;
// 等同于int a;

• unsigned int ⾥⾯的 int 可以省略，所以上⾯的变量声明也可以写成下⾯这样。

unsigned a;

4.char类型的signed和unsigned

字符类型 char 也可以设置 signed 和 unsigned 。

signed char c; // 范围为 -128 到 127
unsigned char c; // 范围为 0 到 255

注意，C 语⾔规定 char 类型默认是否带有正负号，由当前系统决定。这就是说， char 不等同于 signed char ，它有可能是 signed char ，也有可能是unsigned char 。这⼀点与 int 不同， int 就是等同于 signed int 。

*数据类型的取值范围

上述的数据类型很多，尤其数整型类型就有short、int、long、long long 四种，为什么呢？
其实每⼀种数据类型有⾃⼰的取值范围，也就是存储的数值的最⼤值和最⼩值的区间，有了丰富的类型，我们就可以在适当的场景下去选择适合的类型。如果要查看当前系统上不同数据类型的极限值：

limits.h⽂件中说明了整型类型的取值范围。 float.h这个头⽂件中说明浮点型类型的取值范围。
为了代码的可移植性，需要知道某种整数类型的极限值时，应该尽量使⽤这些常量。

• SCHAR_MIN， SCHAR_MAX ：signed char 的最⼩值和最⼤值。
• S HRT_MIN ， HRT_MAXS ：short 的最⼩值和最⼤值。
• INT_MIN ， INT_MAX ：int 的最⼩值和最⼤值。
• LONG_MIN ， LONG_MAX ：long 的最⼩值和最⼤值。
• LLONG_MIN ， LLONG_MAX ：long long 的最⼩值和最⼤值。
• UCHAR_MAX ：unsigned char 的最⼤值。
• USHRT_MAX ：unsigned short 的最⼤值。
• UINT_MAX ：unsigned int 的最⼤值。
• ULONG_MAX ：unsigned long 的最⼤值。
• ULLONG_MAX ：unsigned long long 的最⼤值。

四、C语言的六种token

C 程序由各种令牌（token）组成,分别是

• 关键字
• 标识符
• 常量
• 字符串
• 操作符(运算符)
• 特殊符号

（1）关键字

关键字是c语言内置的,关键字不是自己创建出来的,也不能自己创建

1.关键字解读

在定义变量名的时候,不能与关键字冲突

auto  break   case  char  const   continue  default  do   double else  enum   extern float  for   goto  if   int   long  register    return   short  signed sizeof   static struct  switch  typedef union  unsigned   void  volatile  while

1. auto修饰函数变量的,实际上是放在局部变量前面的,是自动变量
   auto int a = 10;但是所有的局部变量都是auto类型的,所以可以省略
2. break,continue是用来跳出循环的,通常是和for,while,do while一起出现的
3. case是和switch,default一起出现的
4. const表示的是常属性的意思
5. enum-枚举,struct-结构体,union-联合体
6. extern用来声明外部符号的
7. goto实现跳转的语句
8. register是寄存器的意思
9. signed有符号的,unsigned无符号的
10. sizeof计算大小
11. static静态的,修饰函数变量的
12. typedef类型重命名
13. void无(函数的返回类型,函数的参数)
14. volatile

注意:define不是关键字,是预处理指令.

2.register寄存器关键字

引入: 电脑上的存储设备有哪些?

寄存器(集成到CPU上) 高速缓存(cache) 内存 硬盘

从上到下

1. 访问速度递减
2. 造价降低,空间变大

int main()
{
    register int num = 3;//建议存放在寄存器中,以加快运行速度,但最终还是由编译器决定的是否存入寄存器
    return 0;
}

（2）标识符

1.标识符的含义

标识符就是编程时使用的"名字",给类,接口,方法,变量,常量名,包名等起名字的字符序列

2.标识符的组成

英文大小写字母、数字、下划线（ _ ）和美元符号（ $ ） (可以使用汉字或其他合法字符命名，但是不推荐)

3.定义规则（硬性要求）

• 不能以数字开头
• 不能是关键字
• 严格区分大小写

4.命名规范（非硬性要求）

1. 类和接口 首个字母大写，如果有多个单词，每个单词首字母大写：HelloWorld、Student
2. 变量和方法 首字母小写，如果有多个单词，从第二个单词开始首字母大写：getName、studyJava

5.常量名（自定义常量）

所有字母都大写，多个单词用下划线隔开( _ ) :MAX_VALUE

6.包名

全部小写，如果有多级，用点号（ . ）隔开、遵循域名反写的格式：com.liyahui.demo (demo 指 包的功能)

（3）常量

在介绍常量的同时，介绍一下变量，注意变量不是c语言的令牌（token）

不变的值称为常量,可变的值称为变量

*变量

1.初始化变量

类型是用来创建变量的。
data_type + name

char ch = 'w'
int weight = 120
int salary = 20000
double price = 66.6

2.局部变量和全局变量

变量分为局部变量和全局变量
{}外面的变量称为全局变量,
{}内部的变量称为局部变量.

包括在另一个文件里面的,也算全局变量,但是在使用之前,要声明外部变量,使用extern+数据类型+名字来声明变量

int a = 100;
int main()
{
	int a = 10;
	printf("a=%d\n", a);        
	return 0;
}

输出结果为10,
当全局变量与局部变量冲突时,局部优先,没有局部,只能全局。不要让局部变量和全局变量取一样的名.

int main()
{
	int num1 = 0;
	int num2 = 0;
	scanf("%d %d", &num1, &num2);
	int sum = num1 + num2;
	printf("%d\n", sum);
    return 0;
}

&表示取地址,scanf表示扫描输入

3.变量的作用域和生命周期

变量的作用域（scope）是程序设计概念，通常来说，一段程序代码中所有用到的名字并不总是有效/可用的,而限定这个名字的可用性的代码范围就是这个名字的作用域.

局部变量的作用域
局部变量的作用域是变量所在的局部范围，大包小

//这是一个错误示范
int main()
{
	{
        int a = 12;
		printf("a=%d\n", a);
	}
	printf("a=%d\n", a);//这里错了
	return  0;
}

局部变量只能在局部生效,第二个printf("a=%d\n", a)无法输出,会报错

int main()
{
	int a = 12;
	{
		printf("a=%d\n", a);
	}
	printf("a=%d\n", a);
	return  0;
}

两个a都可正常输出,因为int a = 12;对外面那个{}以内均适用

全局变量的作用域 全局可用，extern可用于外部，作用域是整个工程

int a = 12;

int main()
{
	{
		printf("a=%d\n", a);
	}
	printf("a=%d\n", a);
   	return  0;
}

两个a的值都可以正常输出

演示全局变量的作用域

int a = 10;

void test()
{
	printf("test-->%d\n", a);
}

int main()
{	
	test();
	{
		printf("a=%d\n", a);
	}
	printf("a=%d\n",a);
	return 0;
}

三个a的值都可正确输出
自定义函数中也可使用

声明外部变量

extern int a;

局部变量的生命周期 进入作用域到出作用域

全局变量的生命周期 整个程序的开始到结束

4.全局变量和局部变量在内存中的存储

⼀般我们在学习C/C++语⾔的时候，我们会关注内存中的三个区域：栈区、堆区、静态区。

1. 局部变量是放在内存的栈区
2. 全局变量是放在内存的静态区
3. 堆区是⽤来动态内存管理的（后期会介绍）

常量

c语言中的常量与变量的定义形式有所差异.
(常量即为不变的量.)
c语言中的常量可以分为以下几种:

• 字面常量
• const修饰的常变量
• #define定义的标识符常量
• 枚举常量

1.字面常量

数字30,3.14浮点,整型,字符'w',字符串'abc'

2.const修饰的常变量

在int a = 0前面加上const(adj恒定的)
在c语言中,const修饰的a,本质是变量,但是不能直接修改,有常量的属性,也有变量的属性.

const int n = 10
int arr[n] = {0}

这么做会报错，因为arr中应放常量，而const int n具有变量的成分

3.#define定义的标识符常量

#define MAX 100 Max的值可以直接拿来使用,甚至可以拿来给另一个变量赋值,全局可用,可视为全局常量
也可以#define STR "abcd" ,定义为字符串

#define MAX 100
int main()
{
	printf("%d\n", MAX);
    int a = MAX;
    printf("%d\n", a);
	return 0;
}

会输出两个100

4.枚举常量

(未来的所有s可能取值)
用enum+空格+名字

enum color
{
    RED
    GREEN
	BULE
}

int main()
{
	int num = 10;
	enum Color c = RED;
}

枚举常量的值不可更改

（4）字符串

1.字符常量,字符变量,字符串的辨析

char字符类型,
'a'是字符常量,(用单引号)

char ch = 'w'

char创建的ch是字符变量，把字符常量放入字符变量当中去。"abcdef"称为字符串，用双引号引起来的一串字符称为字符串字面值，或者简称字符串.

c语言中没有字符串类型.

0-数字0
'0'-字符0 - ASCLL值是48
'\0'-字符-ASCLL值是0
EOF-end of file文件结束的标志,值是-1

2.如何存储字符串?

字符串的结束标志是一个\0的转义字符,在计算字符串长度的时候\0是结束标志,不算作字符串内容.
使用数组来存储字符串.
数组是一组相同类型元素的集合.

例如:

char arr1[10] = "abcdef"  

其中10表示可以存10个,可以省略自动分配,实际需要7个字符. 字符串的结束标志是一个\0的转译字符,所以实际上需要7个位置,会自动停止.

int main()
{
	char arr1[10] = "abcdef";
    char arr2[ ] = {'a','b','c','d','e','f'};
	printf("%s\n", arr1);
	printf("%s\n", arr2); //一定要遇到\0才会停，这种情况会乱码.
}

以上代码的结果:
abcdef
abcdefabcdef

解决办法,可以再追加'\0',以防乱码

char arr2[ ] = {'a','b','c','d','e','f','\0'};
printf("%s\n", arr2);

3.求字符串的长度

库函数strlen(string length),最佳解决方式,空格也算,不包括\0,
注意:需要引入头文件.

#include <string.h>

计算长度

int len = strlen("abc");
printf("%d\n", len);

或者

printf("%d\n",strlen("abc"));

注意点:strlen()里面的数组如果后面没有\0"则会输出随机数

int main()
{
    char acX[] = "abcdefg";
    char acY[] = { 'a','b','c','d','e','f','g'};
    printf("%d\n",sizeof(acX));
    printf("%d\n",sizeof(acY));
    printf("%d\n",strlen(acX));
    printf("%d\n",strlen(acY));
    return 0;
}

结果是：
8
7
7
14（会输出随机数）

（5）操作符（运算符）

c语言是非常灵活的,C语言提供了非常丰富的操作符,使得使用起来就比较灵活.操作符就是平时用起来习以为常,但是不可或缺的符号.

*操作符的分类

• 算术操作符： + 、- 、* 、/ 、%
• 移位操作符: << >>
• 位操作符: & | ^
• 赋值操作符: = 、+= 、 -= 、 *= 、 /= 、%= 、<<= 、>>= 、&= 、|= 、^=
• 单⽬操作符:！、++、--、&、*、+、-、~ 、sizeof、(类型)
• 关系操作符: > 、>= 、< 、<= 、 == 、 !=
• 逻辑操作符：&& 、||
• 条件操作符：? :
• 逗号表达式：,
• 下标引⽤：[]
• 函数调⽤：()
• 结构成员访问：. 、->

1.算术操作符(双目)

有+、-、*、/、%这些

其中/是除运算,%是取模(取余数)运算.

这些操作符都是双目操作符。 他们都是有2个操作数的，位于操作符两端的就是它们的操作数，这种操作符也叫双目操作符。

• \除运算

演示

int main()
{
    int a = 7 / 2;
    //如果是float a =7/2,结果为3.0，原因就在于 C 语⾔⾥⾯的整数除法是整除，只会返回整数部分，丢弃⼩数部分。
    printf("%d\n",a);
    float b =7 / 2.0;
    printf("%f\n",b);//除号两端都是整数的时候,执行的是整数除法,如果两端只要有一个浮点数就执行浮点数的除法.
    printf("%.1f\n",b);//结果保留一位小数,`.2`则表示保留两位,以此类推.
}

再看⼀个例子：

#include <stdio.h>
int main()
{
   int score = 5;
   score = (score / 20) * 100;
   return 0;
}
//结果为0

上⾯的代码，你可能觉得经过运算， score 会等于 25 ，但是实际上 score 等于 0 。这是因为 score / 20 是整除，会得到⼀个整数值 0 ，所以乘以 100 后得到的也是 0 。 为了得到预想的结果，可以将除数 20 改成 20.0 ，让整除变成浮点数除法。

#include <stdio.h>
int main()
{
   int score = 5;
   score = (score / 20.0) * 100;
   return 0;
}
//结果为0

• %取模运算

运算符 % 表⽰求模运算，即返回两个整数相除的余值。这个运算符只能⽤于整数，不能⽤于浮点数。

int c = 7 % 2;
printf("%d\n",c);//取模是不能写浮点数的

负数求模的规则是，结果的正负号由第⼀个运算数的正负号决定。

#include <stdio.h>
int main()
{
   printf("%d\n", 11 % -5); // 1
   printf("%d\n",-11 % -5); // -1
   printf("%d\n",-11 % 5); // -1
   return 0;
}

上⾯⽰例中，第⼀个运算数的正负号（ 11 或 -11 ）决定了结果的正负号。

2.移位操作符

<< 左移操作符
>>右移操作符
>> << (涉及二进制)
注：移位操作符的操作数只能是整数。

左移操作符

移位规则：左边抛弃、右边补0

#include <stdio.h>
int main()
{
    int num = 10;
    int n = num<<1;//num的值是不变的
    printf("n= %d\n", n);
    printf("num= %d\n", num);
    return 0;
}

右移操作符

移位规则：首先右移运算分两种：

1.逻辑右移：左边用0填充，右边丢弃
2.算数右移：左边用原该值的符号位填充，右边丢弃

注意：对于移位运算符，不要移动负数位，这个是标准未定义的。

3.位操作符

& ^ | ~ 按位与
按位或
按位异或
按位取反
注：他们的操作数必须是整数。

#include <stdio.h>
int main()
{
    int num1 = -3;
    int num2 = 5;
    printf("%d\n", num1 & num2);
    printf("%d\n", num1 | num2);
    printf("%d\n", num1 ^ num2);
    printf("%d\n", ~0);
    return 0;
}

⼀道变态的⾯试题： 不能创建临时变量（第三个变量），实现两个整数的交换。

#include <stdio.h>
int main()
{
    int a = 10;
    int b = 20;
    a = a^b;
    b = a^b;
    a = a^b;
    printf("a = %d b = %d\n", a, b);
    return 0;
}

练习1：编写代码实现：求⼀个整数存储在内存中的⼆进制中1的个数。

//⽅法1
#include <stdio.h>
int main()
{
    int num = 10;
    int count= 0;//计数
    while(num)
    {
        if(num%2 == 1)
            count++;
        num = num/2;
    }
    printf("⼆进制中1的个数 = %d\n", count);
    return 0;
}


//⽅法2：
#include <stdio.h>
int main()
{
    int num = -1;
    int i = 0;
    int count = 0;//计数
    for(i=0; i<32; i++)
    {
        if( num & (1 << i) )
            count++; 
    }
    printf("⼆进制中1的个数 = %d\n",count);
    return 0;
}


//⽅法3：
#include <stdio.h>
int main()
{
    int num = -1;
    int i = 0;
    int count = 0;//计数
    while(num)
    {
        count++;
        num = num&(num-1);
    }
    printf("⼆进制中1的个数 = %d\n",count);
    return 0;
}
//这种⽅式是不是很好？达到了优化的效果，但是难以想到。

练习2：⼆进制位置0或者置1

编写代码将13⼆进制序列的第5位修改为1，然后再改回0

13的2进制序列： 00000000000000000000000000001101
将第5位置为1后：00000000000000000000000000011101
将第5位再置为0：00000000000000000000000000001101

参考代码：

#include <stdio.h>
int main()
{
    int a = 13;
    a = a | (1<<4);
    printf("a = %d\n", a);
    a = a & ~(1<<4);
    printf("a = %d\n", a);
    return 0;
}

4.赋值操作符

在变量创建的时候给⼀个初始值叫初始化，在变量创建好后，再给⼀个值，这叫赋值。

int a = 100;//初始化
a = 200;//赋值，这⾥使⽤的就是赋值操作符

赋值操作符=是⼀个随时可以给变量赋值的操作符。

• 连续赋值

赋值操作符也可以连续赋值，如：

int a = 3;
int b = 5;
int c = 0;
c = b = a+3;////连续赋值，从右向左依次赋值的。

C语⾔虽然⽀持这种连续赋值，但是写出的代码不容易理解，建议还是拆开来写，这样⽅便观察代码的执⾏细节。

• 复合操作符

在写代码时，我们经常可能对⼀个数进⾏⾃增、⾃减的操作，如下代码：

int a = 10;
a += 3;
a -= 2;

复合操作符还有

= += -= *= /= &= 

^= |= >>= <<=

5.单目操作符

前⾯介绍的操作符都是双⽬操作符，有2个操作数的。C语⾔中还有⼀些操作符只有⼀个操作数，被称为单⽬操作符。 ++、--、+(正)、-(负) 就是单⽬操作符的。

• ++和--

++是⼀种⾃增的操作符，⼜分为前置++和后置++，--是⼀种⾃减的操作符，也分为前置--和后置--.

前置++

int a = 10;
int b = ++a;//++的操作数是a，是放在a的前⾯的，就是前置++
printf("a=%d b=%d\n",a , b);

计算⼝诀：先+1，后使⽤； a原来是10，先+1，后a变成了11，再使⽤就是赋值给b，b得到的也是11，所以计算技术后，a和b都是11，相当于这样的代码：

int a = 10;
a = a+1;
b = a;
printf("a=%d b=%d\n",a , b);

后置++

int a = 10;
int b = a++;//++的操作数是a，是放在a的后⾯的，就是后置++
printf("a=%d b=%d\n",a , b);

计算⼝诀：先使⽤，后+1 a原来是10，先使⽤，就是先赋值给b，b得到了10，然后再+1，然后a变成了11，所以直接结束后a是11，b是10，相当于这样的代码：

int a = 10;
int b = a;
a = a+1;
printf("a=%d b=%d\n",a , b);

同理--前置、后置

• - 负值
  用来改变数字前的符号.

• + 正值
  实际上没什么意义.

& 取地址(和指针有关系) *解引用操作符 sizeof是单目操作符,求操作数的类型长度（以字节为单位） .在结构体struct中,.为结构成员访问操作符 ->在结构体struct中,->用于连接结构体指针变量和成员名称

int main()
{
    int arr[10] = { 0 };//初始化数组
    printf("%d\n",sizeof(arr));
    //结果为40,计算的是整个数组的大小,单位是字节
    printf("%d\n",sizeof(arr[10]));
    //计算的结果为4,是数组中的一个元素的大小,单位是字节
    printf("%d\n",sizeof(arr)/sizeof(arr[0]));
    //输出的结果为10,是数组元素的个数
}

~
对一个数的二进制按位取反(后面学)

*间接访问操作符(解引用操作符)(后续会解释)

(类型)强制类型转换,括号内的类型是想要转换的类型 在c语言中,对于像3.14这样的的字面浮点数,编译器默认理解为double类型

int a = (int)3.14
printf("%d\n",a);

6.关系操作符

C 语⾔⽤于⽐较的表达式，称为 “关系表达式”（relational expression），⾥⾯使⽤的运算符就称为“关系运算符”（relational operator），主要有下⾯6个。

• >大于操作符
• >=⼤于等于运算符
• <⼩于运算符
• <=⼩于等于运算符
• !=不相等运算符
• ==相等运算符

关系表达式通常返回 0 或 1 ，表⽰真假。
C 语⾔中， 0 表⽰假，所有⾮零值表⽰真。⽐如， 20 > 12 返回 1 ， 12 > 20 返回 0 。

关系表达式常⽤于 if 或 while 结构。

if (x == 3)
{
   printf("x is 3.\n");
}

另⼀个需要避免的错误是：多个关系运算符不宜连⽤。

i < j < k

上⾯⽰例中，连续使⽤两个⼩于运算符。这是合法表达式，不会报错，但是通常达不到想要的结果，即不是保证变量j的值在i和 k 之间。因为关系运算符是从左到右计算，所以实际执⾏的是下⾯的表达式。

(i < j) < k

上⾯式⼦中， i < j 返回 0 或 1 ，所以最终是 0 或 1 与变量 k 进⾏⽐较。如果想要判断变量j的值是否在 i 和 k 之间，应该使⽤下⾯的写法。

i < j && j < k

7.逻辑操作符

• && 逻辑与

&& 就是与运算符，也是并且的意思， && 是⼀个双⽬操作符，使⽤的⽅式是 a&&b , && 两边的表达式都是真的时候，整个表达式才为真，只要有⼀个是假，则整个表达式为假。

• || 逻辑或

|| 就是或运算符，也就是或者的意思， || 也是⼀个双⽬操作符，使⽤的⽅式是 a || b ， ||两边的表达式只要有⼀个是真，整个表达式就是真，两边的表达式都为假的时候，才为假。

int main()
{
    int a = 10;
    int b = 4;
    if (a && b)//(a || b)
    {
        printf("hehe\n");
    }
    return 0;
}

• ! 逻辑反操作

c语言中,0表示假

非0表示真,!的作用就是把假的变成真的,把真的变成假的

int main()
{
    int flag = 0;//0表示假,非零表示真
    if (!flag)//if语句中默认条件为真时执行
    {
        printf("haha\n");
    }
}

练习 闰年的判断 输⼊⼀个年份year，判断year是否是闰年 闰年判断的规则：

1. 能被4整除并且不能被100整除是闰年
2. 能被400整除是闰年

#include <stdio.h>
//代码1
int main()
{
    int year = 0;
    scanf("%d", &year);
    if(year%4==0 && year%100!=0)
        printf("是闰年\n");
    else if(year%400==0)
        printf("是闰年\n");
 
    return 0;
}
//代码2
int main()
{
    int year = 0;
    scanf("%d", &year);
    if((year%4==0 && year%100!=0) ||(year%400==0))
        printf("是闰年\n");
    return 0;
} 

短路问题

C语⾔逻辑运算符还有⼀个特点，它总是先对左侧的表达式求值，再对右边的表达式求值，这个顺序是保证的。如果左边的表达式满⾜逻辑运算符的条件，就不再对右边的表达式求值。这种情况称为“短路”。 如前⾯的代码:

if(month >= 3 && month <= 5)

表达式中&& 的左操作数是 month >= 3 ，右操作数是 month <= 5 ,当左操作数 month >= 3 的结果是0的时候，即使不判断 month <= 5 ，整个表达式的结果也是0（不是春季）。 所以，对于&&操作符来说，左边操作数的结果是0的时候，右边操作数就不再执⾏。

对于 || 操作符是怎么样呢？我们结合前⾯的代码：

if(month == 12 || month==1 || month == 2)

如果month == 12，则不⽤再判断month是否等于1或者2，整个表达式的结果也是1（是冬季）。所以， || 操作符的左操作数的结果不为0时，就⽆需执⾏右操作数。像这种仅仅根据左操作数的结果就能知道整个表达式的结果，不再对右操作数进⾏计算的运算称为短路求值。

#include <stdio.h>
int main()
{
    int i = 0,a=0,b=2,c =3,d=4;
    i = a++ && ++b && d++;
    //i = a++||++b||d++;
    printf("a = %d\n b = %d\n c = %d\nd = %d\n", a, b, c, d);
    return 0;
}

两种情况结果分别是 a = 1
b = 2
c = 3
d = 4
和
a = 1
b = 3
c = 3
d = 4

8.条件操作符(三目操作符)

三目操作符,有三个操作数
exp1 ? exp2 : exp3
注意符号依次是：问号，冒号，分号

条件操作符的计算逻辑是：如果 exp1 为真， exp2 计算，计算的结果是整个表达式的结果；如果exp1 为假， exp3 计算，计算的结果是整个表达式的结果。

例子

int a = 10;
int b = 20;
int c = (a > b ? a : b);

9.逗号表达式

逗号表达式，就是⽤逗号隔开的多个表达式。
逗号表达式，从左向右依次执⾏。整个表达式的结果是最后⼀个表达式的结果。

下面代码的结果是：

#include <stdio.h>
int main()
{
	int a, b, c;
	a = 5;
	c = ++a;
	b = ++c, c++, ++a, a++;
	b += a++ + c;
	printf("a = %d b = %d c = %d\n:", a, b, c);
	return 0;
}

结果是 a = 9 b= 23 c = 8

//代码1
int a = 1;
int b = 2;
int c = (a>b, a=b+10, a, b=a+1);//逗号表达式
c是多少？


//代码2
if (a =b + 1, c=a / 2, d > 0)

//代码3
a = get_val();
count_val(a);
while (a > 0)
{
    //业务处理
    //...
    a = get_val();
    count_val(a);
}

如果使⽤逗号表达式，改写：
while (a = get_val(), count_val(a), a>0)
{
    //业务处理
}

10.下标访问操作符[]

arr[3]中的[]就是下标引用操作符
arr和3就是[]的操作数

操作数：⼀个数组名 + ⼀个索引值(下标)

int arr[10] = {1,2,3,4,5,6,7,8,9,10};
//创建数组的时候,[]中不能是变量
int n = 3;
arr[n] = 20;//访问元素时,[]中可以是变量

11.函数调用操作符()

接受⼀个或者多个操作数：第⼀个操作数是函数名，剩余的操作数就是传递给函数的参数。

int Add(int x,int y) 
{
    return x+y;
}
int main()
{
    int sum =Add(2,3);//()就是函数调用操作符
    //Add,2,3都是()的操作数
    return 0;
}

12.结构成员访问操作符

什么是结构体

C语⾔已经提供了内置类型，如：char、short、int、long、float、double等，但是只有这些内置类型还是不够的，假设我想描述学⽣，描述⼀本书，这时单⼀的内置类型是不⾏的。描述⼀个学⽣需要名字、年龄、学号、⾝⾼、体重等；描述⼀本书需要作者、出版社、定价等。C语⾔为了解决这个问题，增加了结构体这种⾃定义的数据类型，让程序员可以⾃⼰创造适合的类型。

结构是⼀些值的集合，这些值称为成员变量。结构的每个成员可以是不同类型的变量，如：标量、数组、指针，甚⾄是其他结构体。

结构的声明

struct tag
{
    member-list;
}variable-list;

描述一个学生：
struct Stu
{
    char name[20];//名字
    int age;//年龄
    char sex[5];//性别
    char id[20];//学号
}; //分号不能丢

结构体变量的定义和初始化

//代码1：变量的定义
struct Point
{
    int x;
    int y;
}p1; //声明类型的同时定义变量p1

struct Point p2; //定义结构体变量p2

//代码2:初始化。
struct Point p3 = {10, 20};
struct Stu //类型声明
{
    char name[15];//名字
    int age; //年龄
};
struct Stu s1 = {"zhangsan", 20};//初始化
struct Stu s2 = {.age=20, .name="lisi"};//指定顺序初始化

//代码3
struct Node
{
    int data;
    struct Point p;
    struct Node* next; 
}n1 = {10, {4,5}, NULL}; //结构体嵌套初始化
struct Node n2 = {20, {5, 6}, NULL};//结构体嵌套初始化

结构成员访问操作符

结构体成员的直接访问

结构体成员的直接访问是通过点操作符（.）访问的。点操作符接受两个操作数。如下所⽰：

#include <stdio.h>
struct Point
{
    int x;
    int y;
}p = {1,2};

int main()
{
    printf("x: %d y: %d\n", p.x, p.y);
    return 0;
}

使⽤⽅式：结构体变量.成员名

结构体成员的间接访问

有时候我们得到的不是⼀个结构体变量，⽽是得到了⼀个指向结构体的指针。如下所⽰：

#include <stdio.h>
struct Point
{
    int x;
    int y;
};
int main()
{
    struct Point p = {3, 4};
    struct Point *ptr = &p;
    ptr->x = 10;
    ptr->y = 20;
    printf("x = %d y = %d\n", ptr->x, ptr->y);
    return 0;
}

使⽤⽅式：结构体指针->成员名

#include <stdio.h>
#include <string.h>
struct Stu
{
    char name[15];//名字
    int age; //年龄
};
void print_stu(struct Stu s)
{
    printf("%s %d\n", s.name, s.age);
}
void set_stu(struct Stu* ps)
{
    strcpy(ps->name, "李四");
    ps->age = 28;
}
int main()
{
    struct Stu s = { "张三", 20 };
    print_stu(s);
    set_stu(&s);
    print_stu(s);
    return 0;
}

13.操作符的属性：优先性、结合性

C语⾔的操作符有2个重要的属性：优先级、结合性，这两个属性决定了表达式求值的计算顺序。

优先级

优先级指的是，如果⼀个表达式包含多个运算符，哪个运算符应该优先执⾏。各种运算符的优先级是不⼀样的。

3 + 4 * 5;

上⾯⽰例中，表达式 3 + 4 * 5 ⾥⾯既有加法运算符（ + ），⼜有乘法运算符（ * ）。由于乘法的优先级⾼于加法，所以会先计算 4 * 5 ，⽽不是先计算 3 + 4 。

结合性

如果两个运算符优先级相同，优先级没办法确定先计算哪个了，这时候就看结合性了，则根据运算符是左结合，还是右结合，决定执⾏顺序。⼤部分运算符是左结合（从左到右执⾏），少数运算符是右结合（从右到左执⾏），⽐如赋值运算符（ = ）。

5 * 6 / 2;

上⾯⽰例中， * 和 / 的优先级相同，它们都是左结合运算符，所以从左到右执⾏，先计算 5 * 6 ，再计算 6 / 2 。 运算符的优先级顺序很多，下⾯是部分运算符的优先级顺序（按照优先级从⾼到低排列），建议⼤概记住这些操作符的优先级就⾏，其他操作符在使⽤的时候查看下⾯表格就可以了。

• 圆括号（ () ）
• ⾃增运算符（ ++ ），⾃减运算符（ -- ）
• 单⽬运算符（ + 和 - ）
• 乘法（ * ），除法（ / ）
• 加法（ + ），减法（ - ）
• 关系运算符（ < 、 > 等）
• 赋值运算符（ = ）

由于圆括号的优先级最⾼，可以使⽤它改变其他运算符的优先级。

(6)转义字符

1.转义字符的概念

转义字符就是转变字符的意思

int main()
{
	printf("abcn");
	return 0;
}

输出"abcn"

int main()
{
	printf("abc\n");
    printf("abc\0456");
    //会在\0之后刹车，\0是结束标志。
	return 0;
}

输出两个abc,因为后面那个没有\n,是急停的.

2.c语言中的转义字符

• \?转义防止三字母词(现在不用)
  即早期电脑中
  ??)-->]
??(-->[
• \'用于表示字符常量'

printf("%c\n",'\''); 

• \"用于表示一个字符内部的双引号,同样根据以上printf("\"")输出"

printf("%c\n",'\"'); 

• 为了让printf("abcd\0ef")中的\只是一个普通的\,可以printf("abcd\\0ef"),防止中途刹车

printf("c:\\test\\test.c");

• \n换行符

printf("abc\nefg")
//输出  
//abc  
//efg 

• \t水平制表符，等于按一个tab，算一个字符，体现出来的效果是四个字符
• \ddd表示1-3个八进制0~7的数字，如：\130 --->八进制的130换算成十进制后的ascall码值对应的字母

printf("%c\n",'\130');

• \xdd表示dd这个16进制的数字，如：\x60--->十六进制的60换算成为十进制后的ascall码值对应的字母

printf("%c\n",'\x60');

转义字符长度只算一个长度,如"\t"长度算1

五、C语言中的五大语句

（1）五大语句介绍

什么是语句? c语言中语句可分为以下5类:

1. 表达式语句（表达式语句就是在表达式的后边加上分号。）

#include <stdio.h>
int main()
{
    int a = 20;
    int b = 0;
    b = a + 5; //表达式语句
    return 0;
}

2. 函数调用语句（函数调⽤的时候，也会加上分号，就是函数调⽤语句。）

#include <stdio.h>
int Add(int x, int y)
{
    return x+y;
}
int main()
{
    printf("hehe\n");//函数调⽤语句
    int ret = Add(2, 3);//函数调⽤语句
    return 0;
}

3. 空语句（空语句是最简单的，⼀个分号就是⼀条语句，是空语句）

#include <stdio.h>
int main()
{
    ;//空语句
    return 0;
}

4. 复合语句(其实就是前⾯讲过的代码块，成对括号中的代码就构成⼀个代码块，也被称为复合语句。)

 #include <stdio.h>
void print(int arr[], int sz) //函数的⼤括号中的代码也构成复合语句
{
    int i = 0;
    for(i=0; i<sz; i++)
    {
        printf("%d ", arr[i]);
    }
}
int main()
{
    int i = 0;
    int arr[10] = {0};
    for(i=0; i<10; i++) //for循环的循环体的⼤括号中的就是复合语句
    {
        arr[i] = 10-i;
        printf("%d\n", arr[i]);
    }
    return 0;
}

1. 控制语句 控制语句⽤于控制程序的执⾏流程，以实现程序的各种结构⽅式（C语⾔⽀持三种结构：顺序结构、选择结构、循环结构），它们由特定的语句定义符组成，C语⾔有九种控制语句。 可分成以下三类：

• 条件判断语句也叫分⽀语句：if语句、switch语句；
• 循环执⾏语句：do while语句、while语句、for语句；
• 转向语句：break语句、goto语句、continue语句、return语句

（2）控制语句详解

以下具体讲解控制语句. 控制语句用于控制程序的执行流程,以实现程序的各种结构方式.
C语言支持三种结构:

1. 顺序结构
2. 选择结构
3. 循环结构

1.条件判断语句

c语言中实现选择

• if else 语句
• switch 语句

if else语句

如果表达式中的结果为真,则语句执行. 在C语言中如何表示真假? 0表示假,非0表示真.

语法结构

//无else
if(表达式)
    语句;
//有else
if(表达式)
    语句1;//无论是if还是else,默认后面只能跟上一条语句,后面跟上多条语句时要加上{},否则会报错.
else//表达式为假则执行else
    语句2;
//多分支
if(表达式1)
    语句1;
else if(表达式2)
    语句2;
else (if)
    语句3;
(else)

int main()
{
	int input = 0;
	printf("加入微软亚洲研究院\n");
	printf("要好好学习吗(1/0)?");
	scanf("%d", &input);
	if (input == 1)
	{
		printf("好offer\n");
	}
	else
	{
		printf("卖红薯\n");
	}
	return 0;
}

已知一个函数y=f(x),x<0时,y=1,当x=0时,y=0.当x>0时,y=-1.

int main()
{
    int x = 0;
    int y = 0;
    scanf("%d",&x);
    if (x>0)
        y = -1;
    else if (x==0)
        y = 0;
    else 
        y = 1;
    printf("%d\n",y);
    return 0;
}

else的匹配

else的匹配:else是和它离的最近的if匹配的,并不是和谁对齐就和谁匹配.
当出现以下代码时:

1. 没有加上括号
2. 没有规范缩进

#include <stdio.h>
int main()
{
    int a = 0;
    int b = 2;
    if (a == 1)
        if (b == 2)
            printf("hehe\n");
    else
        printf("haha\n");
    return 0;
}

输出结果为空
应当调整代码格式,适当的使用{}可以使代码的逻辑更加清楚,代码风格很重要.

#include <stdio.h>
int main()
{
    int a = 0;
    int b = 2;
    if (a == 1)
    {
        if (b == 2)
        {
            printf("hehe\n");
        }
    }
    else
    {
        printf("haha\n");
    }       
    return 0;
}

需要注意的细节

if(18<= age <28)//不能这么写
if(age>=18 && age<28)//正确写法

//代码1
if (condition) 
{
    return x;
}
return y;
//代码2
if (condition)
{
    return x;
}
else
{
    return y;
}
//代码3
int num = 1;
if (num == 5)
{
    printf("hehe\n");
}
//代码4
int num = 1;
if (5 == num)
{
    printf("hehe\n");
}

以上代码2和4更好

switch语句

switch语句也是一种分支语句.
常常用于多分支的情况.

语法结构

switch(整型表达式)
{
    语句项；
}

其中语句项是指一些case语句

case 整形常量表达式://注意case后面有空格
    语句;

上⾯代码中，根据表达式 expression 不同的值，执⾏相应的 case 分⽀。如果找不到对应的值，就执⾏ default 分⽀。

注：

1. switch 后的 expression 必须是整型表达式
2. case 后的值，必须是整形常量表达式

break的用法

case只是决定了代码的入口,但是并没有设定代码的出口
在switch语句中的break的作用就体现了
在switch语句中，我们没办法直接实现分支.搭配break使用才能实现真正的分支.

#include <stdio.h>
int main()
{
    int day = 0;
    switch(day)
    {
        case 1：
            printf("星期一\n");
            break;
        case 2:
            printf("星期二\n");
            break;
        case 3:
            printf("星期三\n");
            break;    
        case 4:
            printf("星期四\n");
            break;    
        case 5:
            printf("星期五\n");
            break;
        case 6:
            printf("星期六\n");
            break;
        case 7:
            printf("星期天\n");    
            break;
    }
    return 0;
}

多个case匹配同一个执行语句的写法:

#include <stdio.h>
//switch代码演示
int main()
{
    int day = 0;
    switch(day)
    {
        case 1：
        case 2:
        case 3:
        case 4:
        case 5:
            printf("weekday\n");
            break;
        case 6:
        case 7:
            printf("weekend\n");
            break;
    }
    return 0;
}

switch语句可以嵌套

#include <stdio.h>
int main()
{
    int n = 1;
    int m = 2;
    switch (n)
    {
        case 1:
            m++;
        case 2:
            n++;
        case 3:
            //switch允许嵌套使用
            switch (n)
            {
                case 1:
                    n++;
                case 2:
                    m++;
                    n++;
                    break;
            }
        case 4:
            m++;
            break;
        default:
            break;
    }
    printf("m = %d, n = %d\n", m, n);
    return 0;
}

default子句

如果表达的值与所有的case标签的值都不匹配,那么可以在代码中加入default子句,把default:写在任意一个case标签可以出现的位置,当 switch 表达式的值并不匹配所有 case 标签的值时，这个 default 子句后面的语句就会执行.
所以，每个switch语句中只能出现一条default子句.
但是它可以出现在语句列表的任何位置，而且语句流会像执行一个case标签一样执行default子句.

就⽐如前⾯做的打印星期的练习，如果 day 的输⼊不是1~7的值，如果我们要提⽰：输⼊错误，则可以这样完成代码：

#include <stdio.h>
//switch代码演示
int main()
{
    int day = 0;
    switch(day)
    {
        case 1：
        case 2:
        case 3:
        case 4:
        case 5:
            printf("weekday\n");
            break;
        case 6:
        case 7:
            printf("weekend\n");
            break;
        default:
            printf("输⼊错误\n");
            break;
    }
    return 0;
}

2.循环执行语句

• while循环
• for语句(后面)
• do...while语句(后面)

while语句

语法结构

while(表达式)
    循环语句;

int main()
{
	int line = 0;
	printf("加入集训队\n");
	while (line < 20000)
	{
		printf("写代码:%d\n",line);
		line++;
	}
	if (line >= 20000)
		printf("好offer\n");
	return 0;
}

练习：

输⼊⼀个正的整数，逆序打印这个整数的每⼀位 例如： 输⼊：1234，输出：4 3 2 1 输⼊：521，输出：1 2 5

题⽬解析

1. 要想得到n的最低位，可以使⽤n%10的运算，得到的余数就是最低位，如：1234%10得到4
2. 要想去掉n的最低位，找出倒数第⼆位，则使⽤ n=n/10 操作就可以去掉最低位的，如： n=1234/10得到123，123相较于1234就去掉了最低位，123%10就得到倒数第⼆位3。
3. 循环1和2两个步骤，在n变成0之前，就能到所有的位。

#include <stdio.h>
int main()
{
    int n = 0;
    scanf("%d", &n);
    while(n)
    {
        printf("%d ", n%10);
        n /= 10;
    }
    return 0;
}

while语句中的break

#include <stdio.h>
int main()
{
    int i = 1;
    while(i<=10)
    {

        if (i == 5)
            break;
        printf("%d ", i);
        i++;
    }
    return 0;
}

输出结果:1 2 3 4
总结:
break在while循环中的作用:
其实在循环中只要遇到break，就停止后期的所有的循环，直接终止循环.
所以:while中的break是用于永久终止循环的

while语句中的continue

//continue 代码实例1
#include <stdio.h>
int main()
{
    int i = 1;
    while(i<=10)
    {
        if (i == 5)
        continue;
        printf("%d ",i);
        i = i+1;
    }
    return 0;
}

以上代码输出结果为1 2 3 4

//continue 代码实例2
#include <stdio.h>
int main()
{
    int i = 1;
    while(i<=10)
    {
        i = i+1;
        if (i == 5)
            continue;
        printf("%d ", i);
    }
    return 0;
}

输出结果为:2 3 4 6 7 8 9 10 11 总结:
continue在while循环中的作用
continue是用于终止本次循环的,也就是本次循环中continue后边的代码不会再执行,而是直接跳转到while语句的判断部分.进行下一次循环的入口判断.

for语句

语法结构

for(表达式1; 表达式2; 表达式3)
    循环语句;

• 表达式1为初始化部分，用于初始化循环变量的.
• 表达式2为条件判断部分，用于判断循环时候终止,当判断语句中的条件为真时输出1,则循环继续,否则输出0,则循环结束.
• 表达式3为调整部分，用于循环条件的调整.

例子：使用for循环 在屏幕上打印1-10的数字

#include <stdio.h>
int main()
{
    int i = 0;
    //for(i=1/*初始化*/; i<=10/*判断部分*/; i++/*调整部分*/)
    for(i=1; i<=10; i++)
    {
        printf("%d ", i);
    }
    return 0;
}

for循环和while循环的对比

int i = 0;
//实现相同的功能，使用while
i=1;//初始化部分
while(i<=10)//判断部分
{
    printf("hehe\n");
    i = i+1;//调整部分
}
//实现相同的功能，使用for
for(i=1; i<=10; i++)
{
    printf("hehe\n");
}

可以发现在while循环中依然存在循环的三个必须条件，但是由于风格的问题使得三个部分很可能偏离较远，这样查找修改就不够集中和方便。所以，for循环的风格更胜一筹；for循环使用的频率也最高。

break和continue在for循环中

for如果有多层嵌套,break只能结束当前所在的for循环,而不是所有循环.
在for循环中也可以出现break和continue，他们的意义和在while循环中是一样的。但是还是有些差异：

//代码1
#include <stdio.h>
int main()
{
    int i = 0;
    for(i=1; i<=10; i++)
    {
        if(i == 5)
            break;
        printf("%d ",i);
    }
    return 0;
}
//代码2
#include <stdio.h>
int main()
{
    int i = 0;
    for(i=1; i<=10; i++)
    {
        if(i == 5)
            continue;
        printf("%d ",i);
    }
    return 0;
}

for语句的循环控制变量

建议：

1. 不可在for 循环体内修改循环变量，防止 for 循环失去控制.
2. 建议for语句的循环控制变量的取值采用“前闭后开区间”写法.(并不绝对,要按照具体情况决定)

int i = 0;
//前闭后开的写法
for(i=0; i<10; i++)
{
    ;
}
//两边都是闭区间
for(i=0; i<=9; i++)
{
    ;
}

一些for语句的变种

• 省略初始化语句
• 省略判断语句

代码1

#include <stdio.h>
int main()
{

    for(;;)
    {
        printf("hehe\n");
    }

    //for循环中的初始化部分，判断部分，调整部分是可以省略的，但是不建议初学时省略，容易导致问题。
    //省略判断语句会导致程序死循环(判断条件始终为真)
}

代码2

#include <stdio.h>
int main()
{
    int i = 0;
    int j = 0;
    for(i=0; i<10; i++)
    {
        for(j=0; j<10; j++)
        {
            printf("hehe\n");
        }
    }
    //这里打印多少个hehe?100个
}

代码3

#include <stdio.h>
int main()
{
    int i = 0;
    int j = 0;
    for(; i<10; i++)
    {
        for(; j<10; j++)
        {
            printf("hehe\n");
        }
    }
//如果省略掉初始化部分，这里打印多少个hehe?10个
}

代码4
(使用多余一个变量控制循环)

#include <stdio.h>
int main()
{
    int x, y;
    for (x = 0, y = 0; x<2 && y<5; ++x, y++)
    {
        printf("hehe\n");
    }
    return 0;
}

一道笔试题

//请问循环要循环多少次？
#include <stdio.h>
int main()
{
    int i = 0;
    int k = 0;
    for(i =0,k=0; k=0; i++,k++)
        k++;
    return 0;
}//循环0次,因为判断部分其实是赋值,赋值是用一个"=",而0又代表是假,所以for循环条件不成立,不循环.
//如果是两个"=",那么只循环一次.

do...while()循环

do语句的语法

do
    循环语句;
while(表达式);

do语句的特点

循环至少执行一次，使用的场景有限，所以不是经常使用

#include <stdio.h>
int main()
{
    int i = 10;
    do
    {
        printf("%d\n", i);
        i++;
    }
    while(i<10);
    return 0;
}

输⼊⼀个正整数，计算这个整数是⼏位数？ 例如： 输⼊：1234 输出：4 输⼊：12 输出：2

#include <stdio.h>
int main()
{
    int n = 0;
    scanf("%d", &n);
    int cnt = 0;
    do
    {
        cnt++;
        n = n / 10;
    } while (n);
    printf("%d\n", cnt);
    return 0;
}

这⾥并⾮必须使⽤ do while 语句，但是这个代码就⽐较适合使⽤ do while 循环，因为n即使是0，也是1位数，要统计位数的。

do while循环中的break和continue

break的使用

#include <stdio.h>
int main()
{
    int i = 1;
    do
    {
        if(5 == i)
            break;
        printf("%d\n", i);
        i++;
    }
    while(i<10);
    return 0;
}//输出结果1234

continue的使用

#include <stdio.h>
int main()
{
    int i = 1;
    do
    {
        if(5 == i)
            continue;
        printf("%d\n", i);
        i++;
    }
    while(i<10);
    return 0;
}//输出结果1234

循环综合练习

1.计算n的阶乘

int factorial(int para)
{
    int i = 0;
    int a = 1;
    for(i=1;i<=para;i++)
        a=a*i;
    return a;
}

int main()
{
    int n = 0;
    scanf("%d",&n);
    printf("%d\n",factorial(n));
    return 0;
}

2.计算1!+2!+3!+……+10!

结果:4037913

int main()
{
    int i = 0;
    int a = 1;
    int sum = 0;
    for(i=1;i<=10;i++)
    {
        a *= i;
        sum += a;
    }
    printf("%d",sum);
    return 0;
}

int main()
{
    int n = 0;
    int i = 0;
    int a = 1;
    int output = 0;
    for(n=1;n<=10;n++)
    {
        for(i=1;i<=n;i++)
            {
                a=a*i;
            }   
        output = output + a;
        a = 1;
    }
    printf("%d",output);
    return 0;
}

3. 在一个有序数组中查找具体的某个数字n。（使用二分查找）

二分查找算法演示

int bin_search(int arr[], int left, int right, int key)
{
    int mid = 0;
    while(left<=right)
    {
        mid = (left+right)>>1;
        if(arr[mid]>key)
        {
            right = mid-1;
        }
        else if(arr[mid] < key)
        {
            left = mid+1;
        }
        else
            return mid;//找到了，返回下标
    }
    retrun -1;//找不到
}

int main()
{
    int arr[] ={1,2,3,4,5,6,7,8,9,10};
    int key = 7;
    int sz = sizeof(arr)/sizeof(arr[0]);
    int left = 0;
    int right = sz - 1;
    
    while(left<=right)//注意=不能少
    {
        int mid = (left+right)/2;//这个一定要放在循环里面,否则构不成二分查找,同时这种写法容易导致溢出,所以要换一种写法
        //int mid =left+(right-left)/2;
        if(arr[mid]<key)
        {
            left=mid+1;
        } 
        else if(arr[mid]>key)
        {
            right=mid-1;
        }
        else 
        {
            printf("找到了,下标是%d\n",mid);
            break;
        }
    }
    if(left>right)
    {
        printf("找不到\n");
    }
    return 0;
}

4. 编写代码，演示多个字符从两端移动，向中间汇聚。

int main()
{
    char arr1[] = {"Talk is cheap,show me the code"};
    char arr2[] = {"##############################"};
    int len = strlen(arr1);
    int left = 0;
    int right = len - 1;
    while(left<right)
    {
        arr2[left]=arr1[left];
        arr2[right]=arr1[right];
        sleep(1000);
        left++;
        right--;
        printf("%s\n",arr2);
    }
    return 0;
}

5. 编写代码实现，模拟用户登录情景，并且只能登录三次。（只允许输入三次密码，如果密码正确则提示登录成，如果三次均输入错误，则退出程序。

int main()
{
    char arr[] ={0};
    char key[] ="abcd123456";
    int chance = 3;
    while(chance>0)
    {
        printf("请输入密码\n");
        scanf("%s",arr);//这里无需取地址
        if(strcmp(arr,key)==0)//比较两个字符串的大小,应当使用strcmp()函数
        {
            printf("登陆成功");
            break;
        }
        else
        {
            printf("密码错误,还有%d次机会",chance);
            chance--;
        }
    }
    if(chance==0)
    {
        printf("机会已用完\n");
    }    
    return 0;
}

6. 猜数字游戏

游戏要求：

1. 电脑⾃动⽣成1~100的随机数.
2. 玩家猜数字，猜数字的过程中，根据猜测数据的⼤⼩给出⼤了或⼩了的反馈，直到猜对，游戏结束.

随机数⽣成:
要想完成猜数字游戏，⾸先得产⽣随机数，那怎么产⽣随机数呢？

C语⾔提供了⼀个函数叫 rand，这函数是可以⽣成随机数的

int rand (void);

rand函数会返回⼀个伪随机数，这个随机数的范围是在0~RAND_MAX之间，这个RAND_MAX的⼤⼩是依赖编译器上实现的，但是⼤部分编译器上是32767。

rand函数的使⽤需要包含⼀个头⽂件是：stdlib.h
那我们就测试⼀下rand函数，这⾥多调⽤⼏次，产⽣5个随机数：

#include <stdio.h>
#include <stdlib.h>
int main()
{
    printf("%d\n", rand());
    printf("%d\n", rand());
    printf("%d\n", rand());
    printf("%d\n", rand());
    printf("%d\n", rand());
    return 0;
}

其实rand函数⽣成的随机数是伪随机的，伪随机数不是真正 的随机数，是通过某种算法⽣成的随机数。真正的随机数的是⽆法预测下⼀个值是多少的。⽽rand函数是对⼀个叫“种子”的基准值进⾏运算⽣成的随机数。之所以前⾯每次运⾏程序产⽣的随机数序列是⼀样的，那是因为rand函数⽣成随机数的默认种⼦是1。如果要⽣成不同的随机数，就要让种⼦是变化的。

C语⾔中⼜提供了⼀个函数叫srand，⽤来初始化随机数的⽣成器的，srand的原型如下：

void srand (unsigned int seed);

程序中在调⽤ rand 函数之前先调⽤ srand 函数，通过 srand 函数的参数seed来设置rand函数⽣成随机数的时候的种⼦，只要种⼦在变化，每次⽣成的随机数序列也就变化起来了。那也就是说给srand的种⼦是如果是随机的，rand就能⽣成随机数；在⽣成随机数的时候⼜需要⼀个随机数，这就⽭盾了。

在程序中我们⼀般是使⽤程序运⾏的时间作为种⼦的，因为时间时刻在发⽣变化的。在C语⾔中有⼀个函数叫time,就可以获得这个时间,time函数原型如下：

time_t time (time_t* timer);

time 函数会返回当前的⽇历时间，其实返回的是1970年1⽉1⽇0时0分0秒到现在程序运⾏时间之间的差值，单位是秒。返回的类型是time_t类型的，time_t 类型本质上其实就是32位或者64位的整型类型。

time函数的参数 timer 如果是⾮NULL的指针的话，函数也会将这个返回的差值放在timer指向的内存中带回去。

如果 timer 是NULL，就只返回这个时间的差值。time函数返回的这个时间差也被叫做：时间戳。

time函数的时候需要包含头⽂件：time.h

如果只是让time函数返回时间戳，我们就可以这样写：

time(NULL);//调⽤time函数返回时间戳，这⾥没有接收返回值

那我们就可以让⽣成随机数的代码改写成如下：

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

int main()
{
    //使⽤time函数的返回值设置种⼦
    //因为srand的参数是unsigned int类型，我们将time函数的返回值强制类型转换
    srand((unsigned int)time(NULL));
    printf("%d\n", rand());
    printf("%d\n", rand());
    printf("%d\n", rand());
}

应当注重这句代码:

srand((unsigned int)time(NULL));

srand函数是不需要频繁调⽤的，⼀次运⾏的程序中调⽤⼀次就够了。

设置随机数的范围:

• 如果我们要⽣成0~99之间的随机数，⽅法如下：

rand() % 100;//余数的范围是0~99

• 如果要⽣成1~100之间的随机数，⽅法如下：

rand()%100+1;//%100的余数是0~99,0~99的数字+1,范围是1~100

• 如果要⽣成100~200的随机数，⽅法如下：

100 + rand()%(200-100+1);//余数的范围是0~100，加100后就是100~200

• 所以如果要⽣成a~b的随机数，⽅法如下：

a + rand()%(b-a+1);

猜数字游戏实现:

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
void menu()
{
    printf("**********************************\n");
    printf("*********** 1.play     **********\n");
    printf("*********** 0.exit     **********\n");
    printf("**********************************\n");
}
//RAND_MAX(0-32767)--rand函数能返回随机数的最大值。
void game()
{
    int random_num = rand()%100+1;
    //使用rand()函数生成随机数,但是前提是要用srand函数
    //这里的rand()%100生成的值为0-99之间的数字,加上1之后的数字才是1-100
    int input = 0;
    int count = 5;
    while(count)
    {
        
        printf("请输入猜的数字>:");
        scanf("%d", &input);
        if(input > random_num)
        {
            printf("猜大了\n");
        }
        else if(input < random_num)
        {
            printf("猜小了\n");
        }
        else
        {
            printf("恭喜你，猜对了\n");
            break;
        }
        count--;
        printf("\n你还有%d次机会\n", count);
    }
    if (count == 0)
    {
        printf("你失败了，正确值是:%d\n", r);
    }
}


int main()
{
    int input = 0;
    srand((unsigned int)time(NULL));//时间戳当作随机数,NULL是空指针
    do
    {
        menu();
        printf("请选择>:");
        scanf("%d", &input);
        switch(input)
        {
        case 1:
            game();
            break;
        case 0:
            break;
        default:
            printf("选择错误,请重新输入!\n");
            break;
        }
    }while(input);
    return 0;
}

3.转向语句

goto

C语言中提供了可以随意滥用的 goto语句和标记跳转的标号.
从理论上 goto语句是没有必要的，实践中没有goto语句也可以很容易的写出代码.
但是某些场合下goto语句还是用得着的，最常见的用法就是终止程序在某些深度嵌套的结构的处理过程.
例如：一次跳出两层或多层循环.
多层循环这种情况使用break是达不到目的的。它只能从最内层循环退出到上一层的循环.

for(...)
    for(...)
    {
        for(...)
        {
            if(disaster)
                goto error;
        }
    }
    
error:
 if(disaster)
         // 处理错误情况

下面是使用goto语句的一个例子，然后使用循环的实现方式替换goto语句： 一个关机程序

#include <stdio.h>
int main()
{
    char input[10] = {0};
    system("shutdown -s -t 60");


again:
    printf("电脑将在1分钟内关机，如果输入：我是猪，就取消关机!\n请输入:>");
    scanf("%s", input);
    if(0 == strcmp(input, "我是猪"))
    {
        system("shutdown -a");
    }
    else
    {
        goto again;
    }
    return 0;
}

而如果不适用goto语句，则可以使用循环;

#include <stdio.h>
#include <stdlib.h>
int main()
{
    char input[10] = {0};
    system("shutdown -s -t 60");
    while(1)
    {
        printf("电脑将在1分钟内关机，如果输入：我是猪，就取消关机!\n请输入:>");
        scanf("%s", input);
        if(0 == strcmp(input, "我是猪"))
        {
            system("shutdown -a");
            break;
        }
    }
    return 0;
}

六.C语言的注释

c语言的注释有两种方法

（1）"/**/"法

第⼀种⽅法是将注释放在 /.../ 之间，内部可以分⾏。 不能在注释内嵌套注释，注释也不能出现在字符串或字符值中。

/* 单行注释 */
/* 
 多行注释
 多行注释
 多行注释
*/

以下这种注释是正确的·

int fopen(char* s /* file name */, int mode);

（2）"//"法

以 // 开始的单行注释，这种注释可以单独占一行。

int x = 1; // 这也是注释

不管是哪⼀种注释，都不能放在双引号⾥⾯。
双引号⾥⾯的注释符号，会成为字符串的⼀部分，解释为普通符号，失去注释作⽤。

printf("// hello /* world */ ");

上面示例中，双引号⾥⾯的注释符号，都会被视为普通字符，没有注释作⽤。

（3）注释编译时会被替换

编译时，注释会被替换成⼀个空格，所以min/* 这⾥是注释*/Value会变成min Value，⽽不是minValue。

七、函数

目录

1. 函数是什么
2. 库函数
3. 自定义函数
4. 函数参数
5. 函数调用
6. 函数的嵌套调用和链式访问
7. 函数的声明和定义
8. 函数递归

*函数是什么

在计算机科学中，子程序（英语：Subroutine, procedure, function, routine, method, subprogram, callable unit），是一个大型程序中的某部分代码，由一个或多个语句块组成。它负责完成某项特定任务，而且相较于其他代码，具备相对的独立性。

一般会有输入参数并有返回值，提供对过程的封装和细节的隐藏。这些代码通常被集成为软件库。

（1）函数的分类

1.库函数

为了支持可移植性和提高程序的效率，所以C语言的基础库中提供了一系列类似的库函数,方便程序员开发软件 简单的总结，C语言常用的库函数都有:

• IO函数 <stdio.h>
• 字符串操作函数
• 字符操作函数
• 内存操作函数
• 时间/日期函数
• 数学函数
• 其他库函数

2.自定义函数

自定义函数和库函数一样，有函数名，返回值类型和函数参数。但是不一样的是这些都是我们自己来设计。这给程序员一个很大的发挥空间。

函数的组成：

ret_type fun_name(para1, * )
//当省略不写ret_type时，默认是返回值是int类型的
{
    statement;
}

ret_type 返回类型(return)
fun_name 函数名(function)
para1 函数参数(parameter)
statement 语句

一段求两个数的和的程序

int main()
{
	int n1 = 0;
	int n2 = 0;
	scanf("%d %d", &n1, &n2);
	int sum = n1 + n2;
	printf("%d\n", sum);
	return 0;
}

使用自己定义的函数

int Add(int x,int y) //int是指返回类型
{
    int z =0;
    z = x + y;
    return z;
}
int main()
{
	int n1 = 0;
	int n2 = 0;
	scanf("%d %d", &n1, &n2);
	int sum = Add(n1,n2);
	printf("%d\n", sum);
	return 0;
}

注意:当不需要输出返回值的时候,这个时候往往会将自定义函数名称前面加上void,表示无返回值.

写一个函数可以找出两个整数中的最大值

#include <stdio.h>
//get_max函数的设计
int get_max(int x, int y)
{ 
    return (x>y)?(x):(y);
}

int main()
{
    int num1 = 10;
    int num2 = 20;
    int max = get_max(num1, num2);
    printf("max = %d\n", max);
    return 0;
}

*return语句

在函数的设计中，函数中经常会出现return语句，这⾥讲⼀下return语句使⽤的注意事项。

• return后边可以是⼀个数值，也可以是⼀个表达式，如果是表达式则先执⾏表达式，再返回表达式 的结果。
• return后边也可以什么都没有，直接写 return; 这种写法适合函数返回类型是void的情况。
• return返回的值和函数返回类型不⼀致，系统会⾃动将返回的值隐式转换为函数的返回类型。
• return语句执⾏后，函数就彻底返回，后边的代码不再执⾏。
• 如果函数中存在if等分⽀的语句，则要保证每种情况下都有return返回，否则会出现编译错误。

(2)函数的参数

实参和形参

1. 实际参数(实参)：真实传给函数的参数，叫实参。实参可以是：常量、变量、表达式、函数等。

int c = Add(10,b);
int c = Add(a+3,b);
int c = Add(Add(a,3),b);
//以上均正确
//无论实参是何种类型的量，在进行函数调用时，它们都必须有确定的值，以便把这些值传送给**形参**。

2. 形式参数（形参）：形式参数是指函数名后括号中的变量，因为形式参数只有在函数被调用的过程中才实例化（分配内存单元），所以叫形式参数。**形式参数当函数调用完成之后就自动销毁了。**因此形式参数只在函数中有效。

写一个函数可以交换两个整形变量的内容。

#include <stdio.h>
//实现成函数，但是不能完成任务
void Swap1(int x, int y)
{
    int tmp = 0;
    tmp = x;
    x = y;
    y = tmp;
}
//当实参传递给形参的时候，形参是实参的一份临时拷贝。
//对形参的改变不能改变实参
//正确的版本
void Swap2(int *px, int *py)
{
    int tmp = 0;
    tmp = *px;
    *px = *py;
    *py = tmp;
}
int main()
{
    int num1 = 1;
    int num2 = 2;
    Swap1(num1, num2);
    printf("Swap1: num1 = %d num2 = %d\n", num1, num2);
    Swap2(&num1, &num2);
    printf("Swap2: num1 = %d num2 = %d\n", num1, num2);
    return 0;
}

上面Swap1和Swap2函数中的参数x，y，px，py都是形式参数。在main函数中传给 Swap1 的 num1 ，num2 和传给 Swap2 函数的 &num1 ， &num2 是实际参数。

这里我们对函数的实参和形参进行分析:Swap1 函数在调用的时候， x ， y 拥有自己的空间，同时拥有了和实参一模一样的内容。

所以我们可以简单的认为：形参实例化之后其实相当于实参的一份临时拷贝。

数组作为函数参数

在使⽤函数解决问题的时候，难免会将数组作为参数传递给函数，在函数内部对数组进⾏操作。
⽐如：写⼀个函数对将⼀个整型数组的内容，全部置为-1，再写⼀个函数打印数组的内容。简单思考⼀下，基本的形式应该是这样的：

#include <stdio.h>
int main()
{
    int arr[] = {1,2,3,4,5,6,7,8,9,10};
    set_arr();//设置数组内容为-1
    print_arr();//打印数组内容
    return 0;
}

这⾥的set_arr函数要能够对数组内容进⾏设置，就得把数组作为参数传递给函数，同时函数内部在设置数组每个元素的时候，也得遍历数组，需要知道数组的元素个数。所以我们需要给set_arr传递2个参数，⼀个是数组，另外⼀个是数组的元素个数。仔细分析print_arr也是⼀样的，只有拿到了数组和元素个数，才能遍历打印数组的每个元素。

#include <stdio.h>
int main()
{
    int arr[] = {1,2,3,4,5,6,7,8,9,10};
    int sz = sizeof(arr)/sizeof(arr[0]);
    set_arr(arr, sz);//设置数组内容为-1
    print_arr(arr, sz);//打印数组内容
    return 0;
}

数组作为参数传递给了set_arr 和 print_arr 函数了，那这两个函数应该如何设计呢？ 这⾥我们需要知道数组传参的⼏个重点知识：

• 函数的形式参数要和函数的实参个数匹配
• 函数的实参是数组，形参也是可以写成数组形式的
• 形参如果是⼀维数组，数组⼤⼩可以省略不写
• 形参如果是⼆维数组，⾏可以省略，但是列不能省略
• 数组传参，形参是不会创建新的数组的
• 形参操作的数组和实参的数组是同⼀个数组

根据上述的信息，我们就可以实现这两个函数：

void set_arr(int arr[], int sz)
{
    int i = 0;
    for(i=0; i<sz; i++)
    {
        arr[i] = -1;
    }
}

void print_arr(int arr[], int sz)
{
    int i = 0;
    for(i=0; i<sz; i++)
    {
        printf("%d ", arr[i]);
    }
    printf("\n");
}

(3)函数的调用

函数的调用分为传值调用和传址调用

1.传值调用

函数的形参和实参分别占有不同内存块，对形参的修改不会影响实参。

2.传址调用

• 传址调用是把函数外部创建变量的内存地址传递给函数参数的一种调用函数的方式。
• 这种传参方式可以让函数和函数外边的变量建立起真正的联系，也就是函数内部可以直接操作函数外部的变量。

*练习

1. 写一个函数可以判断一个数是不是素数。

int is_prime(int x)
{
    int flag = 0;
    int i = 0;
    for(i=2;i<=sqrt(x);i++)
    //学习点
    {
        if(x % i == 0)
        {
            flag=1;
            break;
        }
    }
    return flag;
}

int main()
{
    int input = 0;
    printf("%s\n","请输入数字");
    scanf("%d",&input);
    if(is_prime(input)==0)
    {
        printf("%s\n","是素数");
    }
    else
    {
        printf("%s\n","不是素数");
    }
    return 0;
}

2. 写一个函数判断一年是不是闰年。 (闰年判断的规则：1、能被4整除，并且不能被100整除是闰年2、能被400整除是闰年)

int is_run(int year)
{
    flag =0;
    if((year%4==0)&&(year%100!=0)||(year%400==0))
    //学习点
    {
        flag = 1;
    }
    return flag;
}

int main()
{
    int input = 0;
    printf("%s\n","请输入年份");
    scanf("%d",&input);
    if(is_run(input)==0)
    {
        printf("%s\n","不是闰年");
    }
    else
    {
        printf("%s\n","是闰年");
    }
    return 0;
}

3. 写一个函数，实现一个整形有序数组的二分查找。

int binary_search(int arr[],int key,int sz)
{
    //形参arr实际上是指针变量
    //知识点：数组传参实际上传的是数组首元素的地址
    //所以在数组内部计算一个函数参数部分的数组元素个数是不行的
    int left,i= 0;
    int right = sz-1;
    while(left<=right)
    {
        for(i=0;i<sz;i++)
        {
            int mid=left+(right-left)/2;
            if(arr[mid]<key)
            {
                left=mid+1;
            }
            else if(arr[mid]>key)
            {
                right=mid-1;
            }
            else
            {
                return 1;
            }
        }
    }
    return -1;
}
int main()
{
    int arr1[]={0,1,2,3,4,5,6,7,8,9};
    int sz = sizeof(arr1)/sizeof(arr1[0]);
    int key = 0;
    printf("%s\n","输入key的值");
    scanf("%d",&key);
    int ret =binary_search(arr1,key,sz);
    if(ret==1)
    {
        printf("%s","找到了");
    }
    else
    {
        printf("%s","找不到");
    }
    return 0;
}

4. 写一个函数，每调用一次这个函数，就会将 num 的值增加1。

void Add(int* p)
{
    (*p)++;
}
int main()
{
    int num = 0;
    Add(&num);
    printf("%d\n",num);
    Add(&num);
    printf("%d\n",num);
    return 0;
}

以上代码等价于

int Add(int n)
{
    return ++n;
}
int main()
{
    int num = 0;
    num = Add(num);
    printf("%d\n",num);
    num = Add(num);
    printf("%d\n",num);
    return 0;
}

(4)函数的嵌套调用和链式访问

函数和函数之间可以根据实际的需求进行组合的，也就是互相调用的。

1.嵌套调用

void new_line()
{
    printf("hehe\n");
}
void three_line()
{
    int i = 0;
    for(i=0; i<3; i++)
    {
        new_line();
    }
}
int main()
{
    three_line();
    return 0;
}

函数可以嵌套调用，但是不能嵌套定义。
函数与函数之间的地位是平等的，一个函数不能在另一个函数内被调用。

2.链式访问

把一个函数的返回值作为另外一个函数的参数。
链式访问的前提是函数要有返回值。

int main()
{
    int len =strlen("abcdef");
    printf("%d\n",len);
    printf("%d\n",strlen("abcdef"));
    //这就是链式访问
    return 0;
}

int main()
{
    char arr[20] = "hello";
    int ret = strlen(strcat(arr,"bit"));
    //这里介绍一下strlen函数
    printf("%d\n", ret);
    return 0;
}

判断以下程序的结果是什么？

int main()
{
    printf("%d",printf("%d",printf("%d",43)));
    return 0；
}

结果是4321

(5)函数的声明和定义

1.单个⽂件

⼀般我们在使⽤函数的时候，直接将函数写出来就使⽤了。 ⽐如：我们要写⼀个函数判断⼀年是否是闰年。

#include <stido.h>
//判断⼀年是不是闰年
int is_leap_year(int y)
{
    if(((y%4==0)&&(y%100!=0)) || (y%400==0))
        return 1;
    else
        return 0;
}

int main()
{
    int y = 0;
    scanf("%d", &y);
    int r = is_leap_year(y);
    if(r == 1)
        printf("闰年\n");
    else
        printf("⾮闰年\n");
    return 0;
}

上⾯代码中橙⾊的部分是函数的定义，绿⾊的部分是函数的调⽤。 这种场景下是函数的定义在函数调⽤之前，没啥问题。

那如果我们将函数的定义放在函数的调⽤后边，如下：

#include <stido.h>
int main()
{
    int y = 0;
    scanf("%d", &y);
    int r = is_leap_year(y);
    if(r == 1)
        printf("闰年\n");
    else
        printf("⾮闰年\n");
    return 0;
}
//判断⼀年是不是闰年
int is_leap_year(int y)
{
    if(((y%4==0)&&(y%100!=0)) || (y%400==0))
        return 1;
    else
        return 0;
}

这个代码在VS2022上编译，会出现下⾯的警告信息：
这是因为C语⾔编译器对源代码进⾏编译的时候，从第⼀⾏往下扫描的，当遇到第7⾏的is_leap_year函数调⽤的时候，并没有发现前⾯有is_leap_year的定义，就报出了上述的警告。
怎么解决这个问题呢？就是函数调⽤之前先声明⼀下is_leap_year这个函数，声明函数只要交代清楚：函数名，函数的返回类型和函数的参数。如：

int is_leap_year(int y)；

这就是函数声明，函数声明中参数只保留类型，省略掉名字也是可以的。

代码变成这样就能正常编译了。

#include <stdio.h>
int is_leap_year(int y)；//函数声明
int main()
{
    int y = 0;
    scanf("%d", &y);
    int r = is_leap_year(y);
    if(r == 1)
        printf("闰年\n");
    else
        printf("⾮闰年\n");
    return 0;
}

//判断⼀年是不是闰年
int is_leap_year(int y)
{
    if(((y%4==0)&&(y%100!=0)) || (y%400==0))
        return 1;
    else
        return 0;
}

函数的调⽤⼀定要满⾜，先声明后使⽤；
函数的定义也是⼀种特殊的声明，所以如果函数定义放在调⽤之前也是可以的。

2.多个⽂件

⼀般在企业中我们写代码时候，代码可能⽐较多，不会将所有的代码都放在⼀个⽂件中；我们往往会根据程序的功能，将代码拆分放在多个⽂件中。
⼀般情况下，函数的声明、类型的声明放在头⽂件（.h）中，函数的实现是放在源⽂件（.c）⽂件中。
如下：

add.c

//函数的定义
int Add(int x, int y)
{
    return x+y;
}

add.h

//函数的声明
int Add(int x, int y);

test.c

#include <stdio.h>
#include "add.h"
int main()
{
    int a = 10;
    int b = 20;
    //函数调⽤
    int c = Add(a, b);
    printf("%d\n", c);
    return 0;
}

3.static 和 extern

static 和 extern 都是C语⾔中的关键字。
static 是 静态的 的意思，可以⽤来：

• 修饰局部变量
• 修饰全局变量
• 修饰函数 extern 是⽤来声明外部符号的。

在讲解 static 和 extern 之前再讲⼀下：作⽤域和⽣命周期。

**作⽤域(scope)**是程序设计概念，通常来说，⼀段程序代码中所⽤到的名字并不总是有效（可⽤）的，⽽限定这个名字的可⽤性的代码范围就是这个名字的作⽤域。

1. 局部变量的作⽤域是变量所在的局部范围。
2. 全局变量的作⽤域是整个⼯程（项⽬）。

⽣命周期指的是变量的创建(申请内存)到变量的销毁(收回内存)之间的⼀个时间段。

1. 局部变量的⽣命周期是：进⼊作⽤域变量创建，⽣命周期开始，出作⽤域⽣命周期结束。
2. 全局变量的⽣命周期是：整个程序的⽣命周期。

static修饰局部变量

//代码1
#include <stdio.h>
void test()
{
    int i = 0;
    i++;
    printf("%d ", i);
}
int main()
{
    int i = 0;
    for(i=0; i<5; i++)
    {
        test();
    }
    return 0;
}


//代码2
#include <stdio.h>
void test()
{
    //static修饰局部变量
    static int i = 0;
    i++;
    printf("%d ", i);
}
int main()
{
    int i = 0;
    for(i=0; i<5; i++)
    {
        test();
    }
    return 0;
}

对⽐代码1和代码2的效果，理解 static 修饰局部变量的意义。 代码1的test函数中的局部变量i是每次进⼊test函数先创建变量（⽣命周期开始）并赋值为0，然后++，再打印，出函数的时候变量⽣命周期将要结束（释放内存）。
代码2中，我们从输出结果来看，i的值有累加的效果，其实 test函数中的i创建好后，出函数的时候是不会销毁的，重新进⼊函数也就不会重新创建变量，直接上次累积的数值继续计算。

结论：static修饰局部变量改变了变量的⽣命周期，⽣命周期改变的本质是改变了变量的存储类型，本来⼀个局部变量是存储在内存的栈区的，但是被 static 修饰后存储到了静态区。存储在静态区的变量和全局变量是⼀样的，⽣命周期就和程序的⽣命周期⼀样了，只有程序结束，变量才销毁，内存才回收。但是作⽤域不变的。

使⽤建议：未来⼀个变量出了函数后，我们还想保留值，等下次进⼊函数继续使⽤，就可以使⽤static修饰。

static修饰全局变量

代码一：

add.c

int g_val = 2018;

test.c

#include <stdio.h>
extern int g_val;
int main()
{
    printf("%d\n", g_val);
    return 0;
}

代码二： add.c

static int g_val = 2018;

test.c

#include <stdio.h>
extern int g_val;
int main()
{
    printf("%d\n", g_val);
    return 0;
}

extern 是⽤来声明外部符号的，如果⼀个全局的符号在A⽂件中定义的，在B⽂件中想使⽤，就可以使⽤ extern 进⾏声明，然后使⽤。

代码1正常，代码2在编译的时候会出现链接性错误。

结论：
⼀个全局变量被static修饰，使得这个全局变量只能在本源⽂件内使⽤，不能在其他源⽂件内使⽤。 本质原因是全局变量默认是具有外部链接属性的，在外部的⽂件中想使⽤，只要适当的声明就可以使⽤；但是全局变量被 static 修饰之后，外部链接属性就变成了内部链接属性，只能在⾃⼰所在的源 ⽂件内部使⽤了，其他源⽂件，即使声明了，也是⽆法正常使⽤的。 使⽤建议：如果⼀个全局变量，只想在所在的源⽂件内部使⽤，不想被其他⽂件发现，就可以使⽤static修饰。

static修饰函数

编写大型工程时,往往会把自定义函数放在另外一个源文件中,这样会更加清晰. 代码1(无static修饰)

//add.c
int Add(int x, int y)
{
    return x+y;
}
//test.c
extern int Add(int x, int y);

int main()
{
    printf("%d\n", Add(2, 3));
    return 0;
}

代码2(有static修饰)

//add.c
static int Add(int x, int y)
{
    return x+y;
}
//test.c
extern int Add(int x, int y);

int main()
{
    printf("%d\n", Add(2, 3));
    return 0;
}

代码1正常，代码2在编译的时候会出现连接性错误. 结论： 其实 static 修饰函数和 static 修饰全局变量是⼀模⼀样的，⼀个函数在整个⼯程都可以使⽤，被static修饰后，只能在本⽂件内部使⽤，其他⽂件⽆法正常的链接使⽤了。 本质是因为函数默认是具有外部链接属性，具有外部链接属性，使得函数在整个⼯程中只要适当的声明就可以被使⽤。但是被 static 修饰后变成了内部链接属性，使得函数只能在⾃⼰所在源⽂件内部 使⽤。

使⽤建议：⼀个函数只想在所在的源⽂件内部使⽤，不想被其他源⽂件使⽤，就可以使⽤ static 修饰。

八、函数的递归

（1）什么是递归

函数⾃⼰调⽤⾃⼰。

#include <stdio.h>
int main()
{
    printf("hehe\n");
    main();//main函数中⼜调⽤了main函数
    return 0;
}

上述就是⼀个简单的递归程序，只不过上⾯的递归只是为了演⽰递归的基本形式，不是为了解决问题，代码最终也会陷⼊死递归，导致栈溢出（Stack overflow）。

1.递归的思想

把⼀个⼤型复杂问题层层转化为⼀个与原问题相似，但规模较⼩的⼦问题来求解；直到⼦问题不能再被拆分，递归就结束了。所以递归的思考⽅式就是把⼤事化⼩的过程。

递归中的递就是递推的意思，归就是回归的意思，接下来慢慢来体会。

2.递归的限制条件

递归在书写的时候，有2个必要条件：

• 递归存在限制条件，当满⾜这个限制条件的时候，递归便不再继续。
• 每次递归调⽤之后越来越接近这个限制条件。 在下⾯的例⼦中，我们逐步体会这2个限制条件。

(2)递归举例

举例1：求n的阶乘

int Fact(int n)
{
    if(n==0)
        return 1;
    else
        return n*Fact(n-1);
}

举例2：顺序打印⼀个整数的每⼀位

void Print(int n)
{
    if(n>9)
    {
        Print(n/10);
    }
    printf("%d ", n%10);

}

int main()
{
    int m = 0;
    scanf("%d", &m);
    Print(m);
    return 0;
}

举例3：求第n个斐波那契数

int Fib(int n)
{
    if(n<=2)
        return 1;
    else
        return Fib(n-1)+Fib(n-2);
}

其实递归程序会不断的展开，在展开的过程中，我们很容易就能发现，在递归的过程中会有重复计算，⽽且递归层次越深，冗余计算就会越多。

（3）递归与迭代

递归是⼀种很好的编程技巧，但是和很多技巧⼀样，也是可能被误⽤的，就像举例1⼀样，看到推导的公式，很容易就被写成递归的形式：

int Fact(int n)
{
    if(n==0)
        return 1;
    else
        return n*Fact(n-1);
}

Fact函数是可以产⽣正确的结果，但是在递归函数调⽤的过程中涉及⼀些运⾏时的开销。

在C语⾔中每⼀次函数调⽤，都要需要为本次函数调⽤在栈区申请⼀块内存空间来保存函数调⽤期间的各种局部变量的值，这块空间被称为运⾏时堆栈，或者函数栈帧。 函数不返回，函数对应的栈帧空间就⼀直占⽤，所以如果函数调⽤中存在递归调⽤的话，每⼀次递归 函数调⽤都会开辟属于⾃⼰的栈帧空间，直到函数递归不再继续，开始回归，才逐层释放栈帧空间。 所以如果采⽤函数递归的⽅式完成代码，递归层次太深，就会浪费太多的栈帧空间，也可能引起栈溢出（stack overflow）的问题。

所以如果不想使⽤递归就得想其他的办法，通常就是迭代的⽅式（通常就是循环的⽅式）。 ⽐如：计算n的阶乘，也是可以产⽣1~n的数字累计乘在⼀起的。

int Fact(int n)
{
    int i = 0;
    int ret = 1;
    for(i=1; i<=n; i++)
    {
        ret *= i;
    }
    return ret;
}

上述代码是能够完成任务，并且效率是⽐递归的⽅式更好的。

事实上，我们看到的许多问题是以递归的形式进⾏解释的，这只是因为它⽐⾮递归的形式更加清晰，但是这些问题的迭代实现往往⽐递归实现效率更⾼。
当⼀个问题⾮常复杂，难以使⽤迭代的⽅式实现时，此时递归实现的简洁性便可以补偿它所带来的运⾏时开销。

再比如斐波那契数列

int Fib(int n)
{
    int a = 1;
    int b = 1;
    int c = 1;
    while(n>2)
    {
        c = a+b;
        a = b;
        b = c;
        n--;
    }
    return c;
}

*青蛙跳阶问题

*汉诺塔问题

九、数组

要存储1-10的数字，怎么存储？

（1）数组概念

C 语言支持数组数据结构，它可以存储一个固定大小(存在溢出问题)的相同类型元素的顺序集合.数组是用来存储一系列数据，但它往往被认为是一系列相同类型的变量.

注意点：

1. 创建数组时，先声明一个数组变量，然后引用变量名+[i]来使用一个数组
2. 所有的数组都是由连续的内存位置组成。最低的地址对应第一个元素，最高的地址对应最后一个元素。
3. 数组中的特定元素可以通过索引访问，第一个索引值为 0。C 语言还允许我们使用指针来处理数组，这使得对数组的操作更加灵活和高效。

（2）使用数组

1.声明数组

在 C 中要声明一个数组，需要指定元素的类型和元素的数量，如下所示：

type_t   arr_name   [const_n];
//type_t 是指数组的元素类型
//const_n 是一个常量表达式，用来指定数组的大小

这叫做一维数组。const_n必须是一个大于零的整数常量，type_t 可以是任意有效的 C 数据类型。

//代码1
int arr1[10];
//代码2
int count = 10;
int arr2[count];//数组时候可以正常创建？不能
//代码3
char arr3[10];
float arr4[1];
double arr5[20];

注：数组创建，在C99标准之前， [] 中要给一个常量才可以，不能使用变量。在C99标准支持了变长数组的概念。

int n = 10;
scanf("%d",&n);//手动输入数字，确定数组大小
int arr[n];

上⾯⽰例中，数组 arr 就是变⻓数组，因为它的⻓度取决于变量 n 的值，编译器没法事先确定，只有运⾏时才能知道 n 是多少。 变⻓数组的根本特征，就是数组⻓度只有运⾏时才能确定，所以变⻓数组不能初始化。它的好处是程序员不必在开发时，随意为数组指定⼀个估计的⻓度，程序可以在运⾏时为数组分配精确的⻓度。有 ⼀个⽐较迷惑的点，变⻓数组的意思是数组的⼤⼩是可以使⽤变量来指定的，在程序运⾏的时候，根据变量的⼤⼩来指定数组的元素个数，⽽不是说数组的⼤⼩是可变的。数组的⼤⼩⼀旦确定就不能再 变化了。

2.初始化数组

数组的初始化是指，在创建数组的同时给数组的内容一些合理初始值。

在 C 中，您可以逐个初始化数组，也可以使用一个初始化语句，如下所示：

int arr[10] = {0};
int arr1[10] = {1,2,3};
//不完全初始化，剩余的元素默认初始化为0
int arr2[] = {1,2,3,4};
int arr3[5] = {1，2，3，4，5}；
char arr4[3] = {'a',98, 'c'};
char arr5[] = {'a','b','c'};
char arr6[] = "abcdef";//只有字符串可以这样写

下面的代码要区分，内存中如何分配

char arr1[10] = "abc";
//a b c \0 0 0 0 0 0 0
char arr2[10] = {'a','b','c'};
//a b c 0 0 0 0 0 0 0
char arr3[]="abc";
//a b c \0
char arr4[]={'a','b','c'};
//a b c 

*注意点

1. 大括号 { } 之间的值的数目不能大于我们在数组声明时在方括号 [ ] 中指定的元素数目。
2. 如果省略掉了数组的大小，数组的大小则为初始化时元素的个数。
3. 所有的数组都是以 0 作为它们第一个元素的索引，也被称为基索引，数组的最后一个索引是数组的总大小减去 1

3.访问数组元素

数组元素可以通过数组名称加索引进行访问。元素的索引是放在方括号内，跟在数组名称的后边。

double salary = balance[9];

实例1：

int main()
{
    int i = 0;
    int arr[10] = {1,2,3,4,5,6,7,8,9,10};
    for(i=0; i<10; i++)
    {
       printf("%d ", arr[i]);
    }
    printf("\n");
    return 0;
}

实例2：

#include <stdio.h>
 
int main ()
{
    int n[ 10 ]; //是一个包含 10 个整数的数组 //
    int i,j;
 
    /* 初始化数组元素 */         
    for ( i = 0; i < 10; i++ )
    {
       n[ i ] = i + 100; /* 设置元素 i 为 i + 100 */
    }
   
    /* 输出数组中每个元素的值 */
    for (j = 0; j < 10; j++ )
    {
       printf("Element[%d] = %d\n", j, n[j] );
    }
 
    return 0;
}

当上面的代码被编译和执行时，它会产生下列结果：

Element[0] = 100
Element[1] = 101
Element[2] = 102
Element[3] = 103
Element[4] = 104
Element[5] = 105
Element[6] = 106
Element[7] = 107
Element[8] = 108
Element[9] = 109

实例3

#include <stdio.h>
int main()
{
    int arr[10] = {0};
    int i = 0;
    int sz = sizeof(arr)/sizeof(arr[0]);
    
    for(i=0; i<sz; ++i)
    {
        printf("&arr[%d] = %p\n", i, &arr[i]);
    }
    return 0;
}

4.获取数组长度

分两种情况：

1. 对于整型数组来说,计算长度

使用 sizeof 运算符来获取数组的长度

int arr[] ={0,1,2,3,4,5}
int sz = sizeof(arr)/sizeof(arr[0]);

使用宏定义

#include <stdio.h>

#define LENGTH(array) (sizeof(array) / sizeof(array[0]))

int main() 
{
    int array[] = {1, 2, 3, 4, 5};
    int length = LENGTH(array);

    printf("数组长度为: %d\n", length);

    return 0;
}

2. 对于非整型数组来说,计算长度

strlen(arr1);

5.数组的输入

#include <stdio.h>
int main()
{
    int arr[10] = {0}; 
    int i = 0;
    for(i=0; i<10; i++)
    {
        scanf("%d", &arr[i]);
    }
    return 0;
}

(3)多维数组

C 语言支持多维数组。多维数组声明的一般形式如下：

type name[size1][size2]...[sizeN];

例如，下面的声明创建了一个三维 5 . 10 . 4 整型数组：

int threedim[5][10][4];

多维数组最简单的形式是二维数组。一个二维数组，在本质上，是一个一维数组的列表。

1.声明二维整型数组

形式如下：

type arrayName [ x ][ y ];

其中，type 可以是任意er有效的 C 数据类型，arrayName 是一个有效的 C 标识符。一个二维数组可以被认为是一个带有 x 行和 y 列的表格。下面是一个二维数组，包含 3 行和 4 列：

int x[3][4];

int arr[3][4];
char arr[3][5];
double arr[2][4];

2.初始化二维数组

• 不完全初始化

int arr1[3][5] = {1,2};
int arr2[3][5] = {0};

• 完全初始化

int arr3[3][5] = {1,2,3,4,5, 2,3,4,5,6, 3,4,5,6,7};

• 按照⾏初始化

int arr4[3][5] = {{1,2},{3,4},{5,6}};

初始化时省略⾏，但是不能省略列

int arr5[][5] = {1,2,3};
int arr6[][5] = {1,2,3,4,5,6,7};
int arr7[][5] = {{1,2}, {3,4}, {5,6}};

3.二维数组的使用

二维数组的使用也是通过下标的方式。

#include <stdio.h>
int main()
{
    int arr[3][4] = {0};
    int i = 0;
    for(i=0; i<3; i++)
    {
        int j = 0;
        for(j=0; j<4; j++)
        {
            arr[i][j] = i*4+j;
        }
    }
    for(i=0; i<3; i++)
    {
        int j = 0;
        for(j=0; j<4; j++)
        {
            printf("%d ", arr[i][j]);
        }
    }
    return 0;
}

(4)数组在内存中的存储

一维数组

仔细观察输出的结果，我们知道，随着数组下标的增长，元素的地址，也在有规律的递增。由此可以得出结论：数组在内存中是连续存放的。

#include <stdio.h>
int main()
{
    int arr[10] = {0};
    int i = 0;
    int sz = sizeof(arr)/sizeof(arr[0]);
    for(i=0; i<sz; ++i)
    {
        printf("&arr[%d] = %p\n", i, &arr[i]);
    }
    return 0;

二维数组

像一维数组一样，这里我们尝试打印二维数组的每个元素。

#include <stdio.h>
int main()
{
    int arr[3][4];
    int i = 0;
    for(i=0; i<3; i++)
    {
        int j = 0;
        for(j=0; j<4; j++)
        {
            printf("&arr[%d][%d] = %p\n", i, j,&arr[i][j]);
        }
    }
    return 0;
}

（5）数组越界

数组的下标是有范围限制的。
数组的下规定是从0开始的，如果数组有n个元素，最后一个元素的下标就是n-1。所以数组的下标如果小于0，或者大于n-1，就是数组越界访问了，超出了数组合法空间的访问。
C语言本身是不做数组下标的越界检查，编译器也不一定报错，但是编译器不报错，并不意味着程序就是正确的。

#include <stdio.h>
int main()
{
    int arr[10] = {1,2,3,4,5,6,7,8,9,10};
    int i = 0;
    for(i=0; i<=10; i++)
    {
        printf("%d\n", arr[i]);//当i等于10的时候，越界访问了
    }
    return 0;
}

二维数组的行和列也可能存在越界。

（6）数组名

在 C 语言中，数组名表示数组的地址，即数组首元素的地址。当我们在声明和定义一个数组时，该数组名就代表着该数组的地址。

例如，在以下代码中：

int myArray[5] = {10, 20, 30, 40, 50};

在这里，myArray 是数组名，它表示整数类型的数组，包含 5 个元素。myArray 也代表着数组的地址，即第一个元素的地址。

数组名本身是一个常量指针，意味着它的值是不能被改变的，一旦确定，就不能再指向其他地方。我们可以使用&运算符来获取数组的地址，如下所示：

int myArray[5] = {10, 20, 30, 40, 50};
int *ptr = &myArray[0];
 // 或者直接写作 int *ptr = myArray;

在上面的例子中,*ptr指针变量被初始化为myArray的地址，即数组的第一个元素的地址。

需要注意的是，虽然数组名表示数组的地址，但在大多数情况下，数组名会自动转换为指向数组首元素的指针。这意味着我们可以直接将数组名用于指针运算，例如在函数传递参数或遍历数组时：

void printArray(int arr[], int size) 
{
    for (int i = 0; i < size; i++) 
    {
        printf("%d ", arr[i]); 
        // 数组名arr被当作指针使用
    }
}


int main()
{
    int myArray[5] = {10, 20, 30, 40, 50};
    printArray(myArray, 5);
    //将数组名传递给函数
    return 0;
}

在上述代码中，printArray 函数接受一个整数数组和数组大小作为参数，我们将 myArray 数组名传递给函数，函数内部可以像使用指针一样使用 arr 数组名。

define定义常量和宏

define定义标识符常量

#define MAX 1000

define定义宏

对于#define ADD(x, y) ((x)+(y)),ADD是宏名,(x, y)是宏的参数,参数是无类型的,((x)+(y))是宏体.
宏是用来替换的. 宏是有参数的. define定义宏

#define ADD(x, y) ((x)+(y))
#include <stdio.h>
int main()
{
    int sum = ADD(2, 3);
    printf("sum = %d\n", sum);
    
    sum = 10*ADD(2, 3);
    printf("sum = %d\n", sum);
    return 0;
}

十、指针

1.内存和地址

内存是电脑上特别重要的存储器,计算机中程序的运行都是在内存中进行的.所以为了有效的使用内存,就把内存划分成一个个小的内存单元,每个内存单元的大小是1个字节.为了能够有效的访问到内存的每个单元,就给内存单元进行了编号,这些编号被称为该内存单元的地址.

给32位电脑的地址线通电,每一个地址线电信号都是1/0,32根地址线,一共可以产生$2^{32}$个序列,等于4GB

变量是创建内存中的（在内存中分配空间的），每个内存单元都有地址，所以变量也是有地址的。

&是取地址操作符

#include <stdio.h>
int main()
{
     int num = 10;//向内存申请4个字节,存储10
     &num;//取出num的地址
    //注：这里num的4个字节，每个字节都有地址，取出的是第一个字节的地址（较小的地址）
     printf("%p\n", &num);//打印地址，%p是以地址的形式打印
     return 0;
}

2.指针变量和地址

在内存单元的编号->地址->地址也被称为是指针, 指针就是用来存放地址的.

存放指针(地址)的变量就是指针变量,指针变量分为全局变量和局部变量

局部变量在代码运行的时候才会指派地址,而全局变量在编译的时候就会分配地址.

2.1取地址操作符

&a取出的是a所占4个字节中地址较⼩的字节的地址。

示意:

int a = 10;
int* p = &a;//这就创建了一个指针变量

*指针变量示意图*

再举一例:以整形指针举例，可以推广到其他类型

char c = "abc";
char * pc = &c; 

2.2指针变量和解引用操作符

*p,记为解引用操作符,意思就是通过p中存放的地址,找到p所指的对象,*p就是p指向的对象.

可以用*p来代替p的对象,并可用于赋值操作.

#include <stdio.h>
int main()
{
    char ch = 'w';
    char* pc = &ch;
    *pc = 'q';//这里直接修改了pc所指向的对象
    printf("%c\n", ch);
    return 0;
}

2.3指针变量的大小

不管是什么类型的指针,都是在创建指针变量,而指针变量是用来存放地址的.指针变量的大小取决于一个地址存放的时候需要多大空间,
32位平台下地址是32个bit位（即4个字节）
64位平台下地址是64个bit位（即8个字节）

#include <stdio.h>
int main()
{
    printf("%d\n", sizeof(char *));
    printf("%d\n", sizeof(short *));
    printf("%d\n", sizeof(int *));
    printf("%d\n", sizeof(double *));
    return 0;
}

结果是：
8
8
8
8

3.指针变量类型的意义

3.1指针的解引用

对⽐，下⾯2段代码，主要在调试时观察内存的变化。

//代码1
#include <stdio.h>
int main()
{
    int n = 0x11223344;  
    int *pi = &n;   
    *pi = 0;  
    return 0;  
}

//代码2
#include <stdio.h>
int main()
{
    int n = 0x11223344;  
    char *pc = (char *)&n;  
    *pc = 0;  
    return 0;  
}

调试我们可以看到，代码1会将n的4个字节全部改为0，但是代码2只是将n的第⼀个字节改为0。

结论：指针的类型决定了，对指针解引⽤的时候有多⼤的权限（⼀次能操作⼏个字节）。

比如： char* 的指针解引⽤就只能访问⼀个字节，⽽ int* 的指针的解引⽤就能访问四个字节。

3.2指针+-整数

先看⼀段代码，调试观察地址的变化。

#include <stdio.h>
int main()
{
    int n = 10;
    char *pc = (char*)&n;
    int *pi = &n;
    printf("%p\n", &n);
    printf("%p\n", pc);
    printf("%p\n", pc+1);
    printf("%p\n", pi);
    printf("%p\n", pi+1);
    return 0;
}

结果是：

我们可以看出，char*类型的指针变量+1跳过1个字节,int*类型的指针变量+1跳过了4个字节。

这就是指针变量的类型差异带来的变化。指针+1，其实跳过1个指针指向的元素。指针可以+1，那也可以-1。

结论：指针的类型决定了指针向前或者向后⾛⼀步有多⼤（距离）。

3.3 void* 指针

在指针类型中有⼀种特殊的类型是 void * 类型的，可以理解为⽆具体类型的指针（或者叫泛型指针），这种类型的指针可以⽤来接受任意类型地址。但是也有局限性， void* 类型的指针不能直接进行指针的+-整数和解引用的运算。

举例：

#include <stdio.h>
int main()
{
    int a = 10;
    int* pa = &a;
    char* pc = &a;
    return 0;
}

在上⾯的代码中，将⼀个int类型的变量的地址赋值给⼀个char* 类型的指针变量。编译器给出了⼀个警告（如下图），是因为类型不兼容。⽽使⽤void*类型就不会有这样的问题。

使⽤void*类型的指针接收地址：

#include <stdio.h>
int main()
{
    int a = 10;
    void* pa = &a;
    void* pc = &a;
 
    *pa = 10;
    *pc = 0;
    return 0;
}

这⾥我们可以看到， void* 类型的指针可以接收不同类型的地址，但是⽆法直接进⾏指针运算。

那么 void* 类型的指针到底有什么⽤呢？

⼀般 void* 类型的指针是使⽤在函数参数的部分，⽤来接收不同类型数据的地址，这样的设计可以实现泛型编程的效果。使得⼀个函数来处理多种类型的数据，

4.const修饰指针

4.1 const修饰变量

变量是可以修改的，如果把变量的地址交给⼀个指针变量，通过指针变量的也可以修改这个变量。

但是如果我们希望⼀个变量加上⼀些限制，不能被修改，怎么做呢？这就是const的作⽤。

#include <stdio.h>
int main()
{
    int m = 0;
    m = 20;//m是可以修改的
    const int n = 0;
    n = 20;//n是不能被修改的
    return 0;
}

上述代码中n是不能被修改的，其实n本质是变量，只不过被const修饰后，在语法上加了限制，只要我们在代码中对n就⾏修改，就不符合语法规则，就报错，致使没法直接修改n。

但是如果我们绕过n，使⽤n的地址，去修改n就能做到了，虽然这样做是在打破语法规则。

#include <stdio.h>
int main()
{
    const int n = 0;
    printf("n = %d\n", n);
    int*p = &n;
    *p = 20;
    printf("n = %d\n", n);
    return 0;
}

输出结果：
n=0;
n=20;

4.2 const修饰指针变量

⼀般来讲const修饰指针变量，可以放在* 的左边，也可以放在* 的右边，意义是不⼀样的。

int * p;//没有const修饰？
int const * p;//const 放在*的左边做修饰
int * const p;//const 放在*的右边做修饰

我们看下⾯代码，来分析具体分析⼀下：

#include <stdio.h>
//代码1 - 测试⽆const修饰的情况
void test1()
{
    int n = 10;
    int m = 20;
    int *p = &n;
    *p = 20;//ok? 可以
    p = &m; //ok? 可以
}

//代码2 - 测试const放在*的左边情况
void test2()
{
    int n = 10;
    int m = 20;
    const int* p = &n;//或者 int const* p = &n;等价
    *p = 20;//ok? 不行
    p = &m; //ok? 仍然可以
}

//代码3 - 测试const放在*的右边情况
void test3()
{
    int n = 10;
    int m = 20;
    int * const p = &n;
    *p = 20; //ok? 可以
    p = &m; //ok? 不可以
}

//代码4 - 测试*的左右两边都有const
void test4()
{
    int n = 10;
    int m = 20;
    int const * const p = &n;
    *p = 20; //ok? 不行
    p = &m; //ok? 不行
}

int main()
{
    //测试⽆const修饰的情况
    test1();
    //测试const放在*的左边情况
    test2();
    //测试const放在*的右边情况
    test3();
    //测试*的左右两边都有const
    test4();
    return 0;
}

结论：const修饰指针变量的时候

• const如果放在*的左边，修饰的是指针指向的内容，保证指针指向的内容不能通过指针来改变。

• const如果放在*的右边，修饰的是指针变量本⾝，保证了指针变量的内容不能修改，但是指针指向的内容，可以通过指针改变。

但是指针变量本⾝的内容可变。

5.指针运算

指针的基本运算有三种，分别是：

• 指针+-整数
• 指针-指针
• 指针的关系运算

5.1指针+-整数

因为数组在内存中是连续存放的，只要知道第⼀个元素的地址，顺藤摸⽠就能找到后⾯的所有元素。

int arr[10] = {1,2,3,4,5,6,7,8,9,10};

#include <stdio.h>
//指针+- 整数
int main()
{
    int arr[10] = {1,2,3,4,5,6,7,8,9,10};
    int *p = &arr[0];
    int i = 0;
    int sz = sizeof(arr)/sizeof(arr[0]);
    for(i=0; i<sz; i++)
    {
        printf("%d ", *(p+i));//p+i 这⾥就是指针+整数
    }
    return 0;
}

5.2指针-指针

写一个函数使其达到strlen函数的效果

//方法一：使用库函数
#include<string.h>
int main()
{
    int len = strlen("abcdef");
    printf("%d\n",len);
    return 0;
}

//方法二：
int my_strlen(char* str)
{
    int count = 0;
    while(*str !='\0')
    {
        count++;
        str++;
    }
    return count;
}

int main()
{
    int len =my_strlen("abcdef");
    printf("%d\n",len);
    return 0;
}

//方法三：递归版本

//方法四：指针-指针
#include <stdio.h>
int my_strlen(char* s)
{
    char *p = s;
    while(*p != '\0')
        p++;
    return p-s;
}
int main()
{
    printf("%d\n", my_strlen("abc"));
    return 0;
}

5.3指针的关系运算

//指针的关系运算
#include <stdio.h>
int main()
{
    int arr[10] = {1,2,3,4,5,6,7,8,9,10};
    int *p = &arr[0];
    int i = 0;
    int sz = sizeof(arr)/sizeof(arr[0]);
    while(p<arr+sz) //指针的⼤⼩⽐较
    {
        printf("%d ", *p);
        p++;
    }
    return 0;
}

5.4辨析

*p++ 和 (*p)++的区别

1. *p++这个是指指针指向的位置为（比如某个位置），然后不操作，再然后p的值加上1
2. (*p)++是指将*p这个指针所指的值加上1

6.野指针

概念： 野指针就是指针指向的位置是不可知的（随机的、不正确的、没有明确限制的）

6.1野指针成因

1. 指针未初始化

#include <stdio.h>
int main()
{ 
    int *p;//局部变量指针未初始化，默认为随机值
    *p = 20;
    return 0;
}

2. 指针越界访问

#include <stdio.h>
int main()
{
    int arr[10] = {0};
    int *p = &arr[0];
    int i = 0;
    for(i=0; i<=11; i++)
    {
    //当指针指向的范围超出数组arr的范围时，p就是野指针
        *(p++) = i;
    }
    return 0;
}

3. 指针指向的空间释放

#include <stdio.h>
int* test()
{
    int n = 100;
    return &n;
}

int main()
{
    int*p = test();
    printf("%d\n", *p);
    return 0;
}

6.2如何规避野指针

6.2.1指针初始化

如果明确知道指针指向哪⾥就直接赋值地址，如果不知道指针应该指向哪⾥，可以给指针赋值NULL. NULL 是C语⾔中定义的⼀个标识符常量，值是0，0也是地址，这个地址是⽆法使⽤的，读写该地址会报错。

初始化如下：

#include <stdio.h>
int main()
{
    int num = 10;
    int*p1 = &num;
    int*p2 = NULL;
 
    return 0;
}

6.2.2小心指针越界

⼀个程序向内存申请了哪些空间，通过指针也就只能访问哪些空间，不能超出范围访问，超出了就是越界访问。

#include <stdio.h>
int* test()
{
    int n = 100;
    return &n;
}

int main()
{
    int*p = test();
    printf("%d\n", *p);
    return 0;
}

6.2.3注意指针有效性

指针变量不再使⽤时，及时置NULL，指针使⽤之前检查有效性

当指针变量指向⼀块区域的时候，我们可以通过指针访问该区域，后期不再使⽤这个指针访问空间的时候，我们可以把该指针置为NULL。因为约定俗成的⼀个规则就是：只要是NULL指针就不去访问，同时使⽤指针之前可以判断指针是否为NULL。 我们可以把野指针想象成野狗，野狗放任不管是⾮常危险的，所以我们可以找⼀棵树把野狗拴起来，就相对安全了，给指针变量及时赋值为NULL，其实就类似把野狗栓起来，就是把野指针暂时管理起 来。 不过野狗即使拴起来我们也要绕着⾛，不能去挑逗野狗，有点危险；对于指针也是，在使⽤之前，我们也要判断是否为NULL，看看是不是被拴起来起来的野狗，如果是不能直接使⽤，如果不是我们再去使⽤。

int main()
{
    int arr[10] = {1,2,3,4,5,67,7,8,9,10};
    int *p = &arr[0];//arr
    for(i=0; i<10; i++)
    {
        *(p++) = i;
    }
    //此时p已经越界了，可以把p置为NULL
    p = NULL;
    //下次使⽤的时候，判断p不为NULL的时候再使⽤
    //...
    p = &arr[0];//重新让p获得地址
    if(p != NULL) //判断
    {
    //...
    }
    return 0;
}

6.2.4避免返回局部变量的地址

如造成野指针的第3个例⼦，不要返回局部变量的地址。

7.assert断言

assert.h 头⽂件定义了宏 assert() ，⽤于在运⾏时确保程序符合指定条件，如果不符合，就报错终⽌运⾏。这个宏常常被称为“断⾔”。

assert(p != NULL);

上⾯代码在程序运⾏到这⼀⾏语句时，验证变量 p 是否等于 NULL 。如果确实不等于 NULL ，程序继续运⾏，否则就会终⽌运⾏，并且给出报错信息提⽰。

assert() 宏接受⼀个表达式作为参数。如果该表达式为真（返回值⾮零）， assert() 不会产⽣任何作⽤，程序继续运⾏。如果该表达式为假（返回值为零）， assert() 就会报错，在标准错误 流 stderr 中写⼊⼀条错误信息，显⽰没有通过的表达式，以及包含这个表达式的⽂件名和⾏号。

assert() 的使⽤对程序员是⾮常友好的，使⽤ assert() 有⼏个好处：它不仅能⾃动标识⽂件和出问题的⾏号，还有⼀种⽆需更改代码就能开启或关闭 assert() 的机制。如果已经确认程序没有问 题，不需要再做断⾔，就在 #include <assert.h> 语句的前⾯，定义⼀个宏 NDEBUG 。

#define NDEBUG
#include <assert.h>

然后，重新编译程序，编译器就会禁⽤⽂件中所有的 assert() 语句。如果程序⼜出现问题，可以移除这条 #define NDEBUG 指令（或者把它注释掉），再次编译，这样就重新启⽤了 assert() 语 句。

assert() 的缺点是，因为引⼊了额外的检查，增加了程序的运⾏时间。

⼀般我们可以在 Debug 中使⽤，在 Release 版本中选择禁⽤ assert 就⾏，在 VS 这样的集成开发环境中，在 Release 版本中，直接就是优化掉了。这样在debug版本写有利于程序员排查问题，在 Release 版本不影响⽤⼾使⽤时程序的效率。

8.指针的使⽤和传址调⽤

8.1 strlen的模拟实现

库函数strlen的功能是求字符串⻓度，统计的是字符串中 \0 之前的字符的个数。 函数原型如下：

 size_t strlen ( const char * str );

参数str接收⼀个字符串的起始地址，然后开始统计字符串中 \0 之前的字符个数，最终返回⻓度。
如果要模拟实现只要从起始地址开始向后逐个字符的遍历，只要不是 \0 字符，计数器就+1，这样直到 \0 就停⽌。
参考代码如下：

int my_strlen(const char * str)
{
    int count = 0;
    assert(str);
    while(*str)
    {
        count++;
        str++;
    }
    return count;
}

int main()
{
    int len = my_strlen("abcdef");
    printf("%d\n", len);
    return 0;
}

8.2 深入理解传址调用和传值调用

学习指针的⽬的是使⽤指针解决问题，那什么问题，⾮指针不可呢？
例如：写⼀个函数，交换两个整型变量的值
⼀番思考后，我们可能写出这样的代码：

#include <stdio.h>
void Swap1(int x, int y)
{
    int tmp = x;
    x = y;
    y = tmp;
}
int main()
{
    int a = 0;
    int b = 0;
    scanf("%d %d", &a, &b);
    printf("交换前：a=%d b=%d\n", a, b);
    Swap1(a, b);
    printf("交换后：a=%d b=%d\n", a, b);
    return 0;
}

我们发现在main函数内部，创建了a和b，a的地址是0x00cffdd0，b的地址是0x00cffdc4，在调⽤Swap1函数时，将a和b传递给了Swap1函数，在Swap1函数内部创建了形参x和y接收a和b的值，但是x的地址是0x00cffcec，y的地址是0x00cffcf0，x和y确实接收到了a和b的值，不过x的地址和a的地址不⼀样，y的地址和b的地址不⼀样，相当于x和y是独⽴的空间，那么在Swap1函数内部交换x和y的值，⾃然不会影响a和b，当Swap1函数调⽤结束后回到main函数，a和b的没法交换。Swap1函数在使⽤的时候，是把变量本⾝直接传递给了函数，这种调⽤函数的⽅式我们之前在函数的时候就知道了，这种叫传值调⽤。

结论：实参传递给形参的时候，形参会单独创建⼀份临时空间来接收实参，对形参的修改不影响实参。

所以Swap是失败的了。

那怎么办呢？

我们现在要解决的就是当调⽤Swap函数的时候，Swap函数内部操作的就是main函数中的a和b，直接将a和b的值交换了。那么就可以使⽤指针了，在main函数中将a和b的地址传递给Swap函数，Swap 函数⾥边通过地址间接的操作main函数中的a和b，并达到交换的效果就好了。

#include <stdio.h>
void Swap2(int* px, int* py)
{
    int tmp = 0;
    tmp = *px;
    *px = *py;
    *py = tmp;
}
int main()
{
    int a = 0;
    int b = 0;
    scanf("%d %d", &a, &b);
    printf("交换前：a=%d b=%d\n", a, b);
    Swap2(&a, &b);
    printf("交换后：a=%d b=%d\n", a, b);
    return 0;
}

我们可以看到实现成Swap2的⽅式，顺利完成了任务，这⾥调⽤Swap2函数的时候是将变量的地址传递给了函数，这种函数调⽤⽅式叫：传址调⽤。

传址调⽤，可以让函数和主调函数之间建⽴真正的联系，在函数内部可以修改主调函数中的变量；所以未来函数中只是需要主调函数中的变量值来实现计算，就可以采⽤传值调⽤。如果函数内部要修改主调函数中的变量的值，就需要传址调⽤。

9.数组名的理解

有这样的代码：

int arr[10] = {1,2,3,4,5,6,7,8,9,10};
int *p = &arr[0];

这⾥我们使⽤ &arr[0] 的⽅式拿到了数组第⼀个元素的地址，但是其实数组名本来就是地址，⽽且是数组⾸元素的地址，我们来做个测试。

#include <stdio.h>
int main()
{
    int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
    printf("&arr[0] = %p\n", &arr[0]);
    printf("arr = %p\n", arr);
    return 0;
}

我们发现数组名和数组⾸元素的地址打印出的结果⼀模⼀样，数组名就是数组⾸元素(第⼀个元素)的地址。

如何理解下面的代码：

#include <stdio.h>
int main()
{
    int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
    printf("%d\n", sizeof(arr));
    return 0;
}

输出的结果是：40，如果arr是数组⾸元素的地址，那输出应该的应该是4/8才对。

其实数组名就是数组⾸元素(第⼀个元素)的地址是对的，但是有两个例外：

• sizeof(数组名)，sizeof中单独放数组名，这⾥的数组名表⽰整个数组，计算的是整个数组的⼤⼩，单位是字节
• &数组名，这⾥的数组名表⽰整个数组，取出的是整个数组的地址（整个数组的地址和数组⾸元素的地址是有区别的）

除此之外，任何地⽅使⽤数组名，数组名都表⽰⾸元素的地址。

再试⼀下这个代码：

#include <stdio.h>
int main()
{
    int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
    printf("&arr[0] = %p\n", &arr[0]);
    printf("arr = %p\n", arr);
    printf("&arr = %p\n", &arr);
    return 0;
}

三个打印结果⼀模⼀样，这时候⼜纳闷了，那arr和&arr有啥区别呢？

#include <stdio.h>
int main()
{
    int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
    printf("&arr[0] = %p\n", &arr[0]);
    printf("&arr[0]+1 = %p\n", &arr[0]+1);
    printf("arr = %p\n", arr);
    printf("arr+1 = %p\n", arr+1);
    printf("&arr = %p\n", &arr);
    printf("&arr+1 = %p\n", &arr+1);
    return 0;
}

输出结果：

&arr[0] = 0077F820
&arr[0]+1 = 0077F824
arr = 0077F820
arr+1 = 0077F824
&arr = 0077F820
&arr+1 = 0077F848

这⾥我们发现&arr[0]和&arr[0]+1相差4个字节，arr和arr+1 相差4个字节，是因为&arr[0] 和 arr 都是⾸元素的地址，+1就是跳过⼀个元素。但是&arr 和 &arr+1相差40个字节，这就是因为&arr是数组的地址，+1 操作是跳过整个数组的。

总结：数组名是数组⾸元素的地址，但是有2个例外。

10.使用指针访问数组

有了前⾯知识的⽀持，再结合数组的特点，我们就可以很⽅便的使⽤指针访问数组了。

#include <stdio.h>
int main()
{
    int arr[10] = {0};
    //输⼊
    int i = 0;
    int sz = sizeof(arr)/sizeof(arr[0]);
    //输⼊
    int* p = arr;
    for(i=0; i<sz; i++)
    {
        scanf("%d", p+i);
        //scanf("%d", arr+i);//也可以这样写
    }
    //输出
    for(i=0; i<sz; i++)
    {
        printf("%d ", *(p+i));
    }
    return 0;
}

这个代码搞明⽩后，我们再试⼀下，如果我们再分析⼀下，数组名arr是数组⾸元素的地址，可以赋值给p，其实数组名arr和p在这⾥是等价的。那我们可以使⽤arr[i]可以访问数组的元素，那p[i]是否也可以访问数组呢？

#include <stdio.h>
int main()
{
    int arr[10] = {0};
    //输⼊
    int i = 0;
    int sz = sizeof(arr)/sizeof(arr[0]);
    //输⼊
    int* p = arr;
    for(i=0; i<sz; i++)
    {
        scanf("%d", p+i);
        //scanf("%d", arr+i);//也可以这样写
    }
    //输出
    for(i=0; i<sz; i++)
    {
        printf("%d ", p[i]);
    }
    return 0;
}

将*(p+i)换成p[i]也是能够正常打印的，所以本质上p[i] 是等价于 *(p+i)。同理arr[i] 应该等价于 *(arr+i)，数组元素的访问在编译器处理的时候，也是转换成⾸元素的地址+偏移量求出元素的地址，然后解引⽤来访问的.

11.⼀维数组传参的本质

数组我们学过了，之前也讲了，数组是可以传递给函数的，这个⼩节我们讨论⼀下数组传参的本质。⾸先从⼀个问题开始，我们之前都是在函数外部计算数组的元素个数，那我们可以把数组传给⼀个函数后，函数内部求数组的元素个数吗？

#include <stdio.h>
void test(int arr[])
{
    int sz2 = sizeof(arr)/sizeof(arr[0]);
    printf("sz2 = %d\n", sz2);
}
int main()
{
    int arr[10] = {1,2,3,4,5,6,7,8,9,10};
    int sz1 = sizeof(arr)/sizeof(arr[0]);
    printf("sz1 = %d\n", sz1);
    test(arr);
    return 0;
}

输出结果：
sz=10；
sz2=1；

我们发现在函数内部是没有正确获得数组的元素个数。
这就要学习数组传参的本质了，上个⼩节我们学习了：数组名是数组⾸元素的地址；那么在数组传参的时候，传递的是数组名，也就是说本质上数组传参传递的是数组⾸元素的地址。

所以函数形参的部分理论上应该使⽤指针变量来接收⾸元素的地址。那么在函数内部我们写sizeof(arr) 计算的是⼀个地址的⼤⼩（单位字节）⽽不是数组的⼤⼩（单位字节）。正是因为函数的参数部分是本质是指针，所以在函数内部是没办法求的数组元素个数的。

void test(int arr[])//参数写成数组形式，本质上还是指针
{
    printf("%d\n", sizeof(arr));
}
void test(int* arr)//参数写成指针形式
{
    printf("%d\n", sizeof(arr));//计算⼀个指针变量的⼤⼩
}
int main()
{
    int arr[10] = {1,2,3,4,5,6,7,8,9,10};
    test(arr);
    return 0;
}

总结：⼀维数组传参，形参的部分可以写成数组的形式，也可以写成指针的形式。

12.数组+冒泡排序

void bubble_sort(int arr[], int sz)
//参数接收数组元素个数
{
    int i = 0;
    for(i=0; i<sz-1; i++)
    {
        int j = 0;
        for(j=0; j<sz-i-1; j++)
        {
            if(arr[j] > arr[j+1])
            {
                int tmp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = tmp;
            }
        }
    }
}

int main()
{
    int arr[] = {3,1,7,5,8,9,0,2,4,6};
    int sz = sizeof(arr)/sizeof(arr[0]);
    bubble_sort(arr,sz);
    int i = 0;
    for(i=0;i<sz;i++)
    {
        printf("%d ",arr[i]);
    }
    return 0;
}

//⽅法2 - 优化
void bubble_sort(int arr[], int sz)//参数接收数组元素个数
{
    int i = 0;
    for(i=0; i<sz-1; i++)
    {
        int flag = 1;//假设这⼀趟已经有序了
        int j = 0;
        for(j=0; j<sz-i-1; j++)
        {
            if(arr[j] > arr[j+1])
            {
                flag = 0;//发⽣交换就说明，⽆序
                int tmp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = tmp;
            }
        }
        if(flag == 1)
        //这⼀趟没交换就说明已经有序，后续⽆序排序了
        break;
    }
}

int main()
{
    int arr[] = {3,1,7,5,8,9,0,2,4,6};
    int sz = sizeof(arr)/sizeof(arr[0]);
    bubble_sort(arr, sz);
    int i = 0;
    for(i=0; i<sz; i++)
    {
        printf("%d ", arr[i]);
    }
    return 0;
}

13.二级指针

指针变量也是变量，是变量就有地址，那指针变量的地址存放在哪⾥？

这就是 ⼆级指针 。

对于⼆级指针的运算有： + `*ppa`通过对ppa中的地址进⾏解引⽤这样找到的是pa,`*ppa`其实访问的就是pa ```c int b = 20; *ppa = &b;//等价于 pa = &b; ```

• **ppa 先通过 *ppa 找到 pa ,然后对 pa 进⾏解引⽤操作： *pa,那找到的是a

**ppa = 30;
//等价于*pa = 30;
//等价于a = 30;

14.指针数组

指针数组是指针还是数组？ 我们类⽐⼀下，整型数组，是存放整型的数组，字符数组是存放字符的数组。

那指针数组呢？是存放指针的数组。

指针数组的每个元素都是⽤来存放地址（指针）的。

指针数组的每个元素是地址，⼜可以指向⼀块区域。

15.指针数组模拟⼆维数组

#include <stdio.h>
int main()
{
    int arr1[] = {1,2,3,4,5};
    int arr2[] = {2,3,4,5,6};
    int arr3[] = {3,4,5,6,7};
    //数组名是数组⾸元素的地址，类型是int*的，就可以存放在parr数组中
    int* parr[3] = {arr1, arr2, arr3};
    int i = 0;
    int j = 0;
    for(i=0; i<3; i++)
    {
        for(j=0; j<5; j++)
        {
            printf("%d ", parr[i][j]);
        }
        printf("\n");
    }
    return 0;
}

parr[i]是访问parr数组的元素，parr[i]找到的数组元素指向了整型⼀维数组，parr[i][j]就是整型⼀维数组中的元素。

上述的代码模拟出⼆维数组的效果，实际上并⾮完全是⼆维数组，因为每⼀⾏并⾮是连续的。

16.字符指针常量

在指针的类型中我们知道有⼀种指针类型为字符指针 char* ; ⼀般使⽤：

int main()
{
    char ch = 'w';
    char *pc = &ch;
    *pc = 'w';
    return 0;
}

还有⼀种使⽤⽅式如下：

int main()
{
    const char* pstr = "hello bit.";
    //这⾥是把⼀个字符串放到pstr指针变量⾥了吗？
    printf("%s\n", pstr);
    return 0;
}

代码 const char* pstr = "hello bit."; 特别容易让同学以为是把字符串 hello bit 放到字符指针 pstr ⾥了，但是本质是把字符串 hello bit. ⾸字符的地址放到了pstr中.

上⾯代码的意思是把⼀个常量字符串的⾸字符 h 的地址存放到指针变量 pstr 中。

#include <stdio.h>
int main()
{
    char str1[] = "hello bit.";
    char str2[] = "hello bit.";
    const char *str3 = "hello bit.";
    const char *str4 = "hello bit.";
    if(str1 ==str2)
        printf("str1 and str2 are same\n");
    else
        printf("str1 and str2 are not same\n");

    if(str3 ==str4)
        printf("str3 and str4 are same\n");
    else
        printf("str3 and str4 are not same\n");

    return 0;
}

**这⾥str3和str4指向的是⼀个同⼀个常量字符串。C/C++会把常量字符串存储到单独的⼀个内存区域，当⼏个指针指向同⼀个字符串的时候，他们实际会指向同⼀块内存。**但是⽤相同的常量字符串去初始化不同的数组的时候就会开辟出不同的内存块。所以str1和str2不同，str3和str4相同。

17.数组指针变量

17.1定义

之前我们学习了指针数组，指针数组是⼀种数组，数组中存放的是地址（指针）。

数组指针变量是指针变量？还是数组？
答案是：指针变量。

我们已经熟悉：

• 整形指针变量： int * pint; 存放的是整形变量的地址，能够指向整形数据的指针。
• 浮点型指针变量： float * pf; 存放浮点型变量的地址，能够指向浮点型数据的指针。

那数组指针变量应该是：存放的应该是数组的地址，能够指向数组的指针变量。

int *p1[10];
int (*p2)[10];

思考⼀下：p1, p2分别是什么？

数组指针变量

int (*p)[10];

解释：p先和结合，说明p是⼀个指针变量，然后指着指向的是⼀个⼤⼩为10个整型的数组。所以p是⼀个指针，指向⼀个数组，叫*数组指针。

这⾥要注意：[]的优先级要⾼于号的，所以必须加上（）来保证p先和结合。

17.2初始化

数组指针变量是⽤来存放数组地址的，那怎么获得数组的地址呢？就是我们之前学习的 &数组名 。

#include <stdio.h>
int main()
{
    int arr[10] = {0};
    printf("%p\n", arr);
    printf("%p\n", &arr);
    return 0;
}

可见数组名和&数组名打印的地址是一样的。

我们再看一段代码：

#include <stdio.h>
int main()
{
    int arr[10] = { 0 };
    printf("arr = %p\n", arr);
    printf("&arr= %p\n", &arr);
    printf("arr+1 = %p\n", arr+1);
    printf("&arr+1= %p\n", &arr+1);
    return 0;
}

根据上面的代码我们发现，其实&arr和arr，虽然值是一样的，但是意义应该不一样的。实际上：&arr 表示的是数组的地址，而不是数组首元素的地址。（细细体会一下）

本例中&arr 的类型是:int(*)[10]，是一种数组指针类型，数组的地址+1，跳过整个数组的大小，所以&arr+1 相对于&arr 的差值是40.

如果要存放个数组的地址，就得存放在数组指针变量中，如下：

int(*p)[10] = &arr;

我们调试也能看到 &arr 和 p 的类型是完全⼀致的。

数组指针类型解析：

int (*p) [10] = &arr;
|    |    |
|    |    |
|    |    p指向数组的元素个数
|    p是数组指针变量名
p指向的数组的元素类型

学了指针数组和数组指针我们来一起回顾并看看下面代码的意思：

int arr[5];//arr是整型数组
int *parr1[10];//parr1是指针数组
int (*parr2)[10];//parr2是数组指针
int (*parr3[10])[5];//parr3是存放数组指针的数组

18.⼆维数组传参的本质

有了数组指针的理解，我们就能够讲⼀下⼆维数组传参的本质了。 过去我们有⼀个⼆维数组的需要传参给⼀个函数的时候，我们是这样写的：

#include <stdio.h>
void test(int a[3][5], int r, int c)
{
    int i = 0;
    int j = 0;
    for(i=0; i<r; i++)
    {
        for(j=0; j<c; j++)
        {
            printf("%d ", a[i][j]);
        }
        printf("\n");
    }
}
int main()
{
    int arr[3][5] = {{1,2,3,4,5}, {2,3,4,5,6},{3,4,5,6,7}};
    test(arr, 3, 5);
    return 0;
}

这⾥实参是⼆维数组，形参也写成⼆维数组的形式，那还有什么其他的写法吗？

⾸先我们再次理解⼀下⼆维数组，⼆维数组其实可以看做是每个元素是⼀维数组的数组，也就是⼆维数组的每个元素是⼀个⼀维数组。那么⼆维数组的⾸元素就是第⼀⾏，是个⼀维数组。

如下图：

所以，根据数组名是数组⾸元素的地址这个规则，⼆维数组的数组名表⽰的就是第⼀⾏的地址，是⼀维数组的地址。根据上⾯的例⼦，第⼀⾏的⼀维数组的类型就是 int [5] ，所以第⼀⾏的地址的类型就是数组指针类型 int(*)[5] 。那就意味着⼆维数组传参本质上也是传递了地址，传递的是第⼀⾏这个⼀维数组的地址，那么形参也是可以写成指针形式的。如下:

#include <stdio.h>
void test(int (*p)[5], int r, int c)
{
    int i = 0;
    int j = 0;
    for(i=0; i<r; i++)
    {
        for(j=0; j<c; j++)
        {
            printf("%d ", *(*(p+i)+j));
        }
        printf("\n");
    }
}
int main()
{
    int arr[3][5] = {{1,2,3,4,5}, {2,3,4,5,6},{3,4,5,6,7}};
    test(arr, 3, 5);
    return 0;
    //数组名arr，表示首元素的地址
    //但是二维数组的首元素是二维数组的第一行
    //所以这里传递的arr，其实相当于第一行的地址，是一维数组的地址
    //可以数组指针来接收
}

总结：⼆维数组传参，形参的部分可以写成数组，也可以写成指针形式。

19.数组参数、指针参数

在写代码的时候难免把数组或者指针传给函数，那么函数的参数该如何设计呢？

19.1一维数组传参

#include <stdio.h>
void test(int arr[])//ok?  正确
{}
void test(int arr[10])//ok?   正确  
{}
void test(int *arr)//ok?   正确
{}


void test2(int *arr[20])//ok?  正确 
{}
void test2(int **arr)//ok?  正确
{}
int main()
{
    int arr[10] = {0};
    int *arr2[20] = {0};
    test(arr);
    test2(arr2);
}

19.2二维数组传参

void test(int arr[3][5])//ok？ 可以
{}
void test(int arr[][])//ok？   不可以，形参的二维数组行{}                             可以省略，列不能省略
void test(int arr[][5])//ok？  可以
{}
//总结：二维数组传参，函数形参的设计只能省略第一个[]的数字。
//因为对一个二维数组，可以不知道有多少行，但是必须知道一行多少元素。
//这样才方便运算。
void test(int *arr)//ok？
{}   //不行，二维数组的数组名其实是首元素的地址，也就是第一行的地址，第一行是一个一维数组的地址

void test(int* arr[5])//ok？   不行，这个是指针数组
{}
void test(int (*arr)[5])//ok？  正确
{}
void test(int **arr)//ok？   不正确
{}

int main()
{
    int arr[3][5] = {0};
    test(arr);
}

19.3一级指针传参

#include <stdio.h>
void print(int *p, int sz)
{
    int i = 0;
    for(i=0; i<sz; i++)
    {
        printf("%d\n",*(p+i));
    }
}

int main()
{
    int arr[10] = {1,2,3,4,5,6,7,8,9};
    int *p = arr;
    int sz = sizeof(arr)/sizeof(arr[0]);
    //一级指针p，传给函数
    print(p, sz);
    return 0;
}

思考：

当一个函数的参数部分为一级指针的时候，函数能接收什么参数？

比如：

void test1(int *p)
{}
//test1函数能接收什么参数？
//int a =10;
//int* prt=&a;
//int arr[10];

//以下都可以接收
//print(&a);
//print(ptr);
//print(arr);

void test2(char* p)
{}
//test2函数能接收什么参数？
//char a ='w';
//char* ptr =&a;
//char arr[10];

//以下都可以接收
//print(&a);
//print(ptr);
//print(arr);

19.4二级指针传参

#include <stdio.h>
void test(int** ptr)
{
    printf("num = %d\n", **ptr);
} 

int main()
{
    int n = 10;
    int*p = &n;
    int **pp = &p;
    test(pp);
    test(&p);
    return 0;
}

思考：

当函数的参数为二级指针的时候，可以接收什么参数？

void test(char **p)
{
}

int main()
{
    char c = 'b';
    char*pc = &c;
    char**ppc = &pc;
    char* arr[10];
    test(&pc);
    test(ppc);
    test(arr);//Ok?   正确
    return 0;
}

20.函数指针变量

20.1函数指针变量的创建

什么是函数指针变量呢？

根据前⾯学习整型指针，数组指针的时候，我们的类⽐关系，我们不难得出结论：

函数指针变量应该是⽤来存放函数地址的，未来通过地址能够调⽤函数的。

那么函数是否有地址呢？ 我们做个测试：

#include <stdio.h>
void test()
{
    printf("hehe\n");
}
int main()
{
    printf("test: %p\n", test);
    printf("&test: %p\n", &test);
    return 0;
}

输出结果如下：

test: 005913CA
&test: 005913CA

确实打印出来了地址，所以函数是有地址的，函数名就是函数的地址，当然也可以通过 &函数名 的⽅式获得函数的地址。

如果我们要将函数的地址存放起来，就得创建函数指针变量咯，函数指针变量的写法其实和数组指针⾮常类似。如下：

void test()
{
    printf("hehe\n");
}

void (*pf1)() = &test;
void (*pf2)()= test;

int Add(int x, int y)
{
    return x+y;
}

int(*pf3)(int, int) = Add;
int(*pf3)(int x, int y) = &Add;
//x和y写上或者省略都是可以的

函数指针类型解析：

int (*pf3) (int x, int y)
 |     |     ------------ 
 |     |     |
 |     |     pf3指向函数的参数类型和个数的交代
 |     函数指针变量名
 pf3指向函数的返回类型

int (*) (int x, int y) //pf3函数指针变量的类型

20.2函数指针变量的使⽤

通过函数指针调⽤指针指向的函数。

#include <stdio.h>
int Add(int x, int y)
{
    return x+y;
}
int main()
{
    int(*pf3)(int, int) = Add;

    printf("%d\n", (*pf3)(2, 3));
    printf("%d\n", pf3(3, 5));//这样写也完全可行
    return 0;
}

输出结果：
5
8

20.3两段有趣的代码

代码1：

(*(void (*)())0)();
这是一次函数调用；先是将整数0强制类型转换为：无参，返回类型是void的函数的地址，调用0地址处的这个函数。

代码2：

void (*signal(int , void(*)(int)))(int);
//申明的signal函数的第一个参数的类型是int，第二个参数是一个函数指针，这个函数指针指向的函数参数是int，返回类型是void，signal函数的返回类型也是一个函数指针，该函数指针指向的函数参数是int，返回类型是void。

两段代码均出⾃：《C陷阱和缺陷》这本书

20.3.1 typedef关键字和指针

typedef 是⽤来类型重命名的，可以将复杂的类型，简单化。

⽐如，你觉得 unsigned int 写起来不⽅便，如果能写成 uint 就⽅便多了，那么我们可以使⽤：

typedef unsigned int uint;

如果是指针类型，能否重命名呢？其实也是可以的，⽐如，将 int* 重命名为 ptr_t ,这样写：

typedef int* ptr_t;

但是对于数组指针和函数指针稍微有点区别：
⽐如我们有数组指针类型 int(*)[5] ,需要重命名为 parr_t ，那可以这样写：

typedef int(*parr_t)[5]; //新的类型名必须在*的右边

函数指针类型的重命名也是⼀样的，⽐如，将 void(*)(int) 类型重命名为 pf_t ,就可以这样写：

typedef void(*pfun_t)(int);//新的类型名必须在*的右边

那么要简化代码2，可以这样写：

typedef void(*pfun_t)(int);
pfun_t signal(int, pfun_t);

21.函数指针数组

数组是⼀个存放相同类型数据的存储空间，我们已经学习了指针数组，⽐如：

int *arr[10];
//数组的每个元素是int*

那要把函数的地址存到⼀个数组中，那这个数组就叫函数指针数组，那函数指针的数组如何定义呢？

int (*parr1[3])();  
int *parr2[3]();   
int (*)() parr3[3];   

答案是：parr1

parr1 先和 [] 结合，说明 parr1是数组，数组的内容是什么呢？

是 int (*)() 类型的函数指针。

22.转移表

函数指针数组的⽤途：转移表
举例：计算器的⼀般实现：

#include <stdio.h>
int add(int a, int b)
{
    return a + b;
}
int sub(int a, int b)
{
    return a - b;
}
int mul(int a, int b)
{
    return a * b;
}
int div(int a, int b)
{
    return a / b;
}
void menu()
{
    printf("*************************\n");
    printf(" 1:add 2:sub \n");
    printf(" 3:mul 4:div \n");
    printf(" 0:exit \n");
    printf("*************************\n");
    printf("请选择：");
}

int main()
{
    int x, y;
    int input = 1;
    int ret = 0;
    do
    {
        menu();
        scanf("%d", &input);
        switch (input)
        {
            case 1:
                printf("输⼊操作数：");
                scanf("%d %d", &x, &y);
                ret = add(x, y);
                printf("ret = %d\n", ret);
                break;
            case 2:
                printf("输⼊操作数：");
                scanf("%d %d", &x, &y);
                ret = sub(x, y);
                printf("ret = %d\n", ret);
                break;
            case 3:
                printf("输⼊操作数：");
                scanf("%d %d", &x, &y);
                ret = mul(x, y);
                printf("ret = %d\n", ret);
                break;
            case 4:
                printf("输⼊操作数：");
                scanf("%d %d", &x, &y);
                ret = div(x, y);
                printf("ret = %d\n", ret);
                break;
            case 0:
                printf("退出程序\n");
                break;
            default:
                printf("选择错误\n");
                break;
        }
    } while (input);
    return 0;
}

使⽤函数指针数组的实现：

#include <stdio.h>
int add(int a, int b)
{
    return a + b;
}
int sub(int a, int b)
{
    return a - b;
}
int mul(int a, int b)
{
    return a*b;
}
int div(int a, int b)
{
    return a / b;
}

void menu()
{
    printf("*************************\n");
    printf(" 1:add 2:sub \n");
    printf(" 3:mul 4:div \n");
    printf(" 0:exit \n");
    printf("*************************\n");
    printf("请选择：");
}


int main()
{
    int x, y;
    int input = 1;
    int ret = 0;
    int (*p[5])(int x, int y) = { 0, add, sub, mul, div }; //转移表
    do
    {
        menu();
        scanf("%d", &input);
        if ((input <= 4 && input >= 1))
        {
            printf( "输⼊操作数：" );
            scanf( "%d %d", &x, &y);
            ret = (*p[input])(x, y);
            printf( "ret = %d\n", ret);
        }
        else if(input == 0)
        {
            printf("退出计算器\n");
        }
        else
        {
            printf("选择错误\n"); 
        }
    }while (input);
    return 0;
}

23.指向函数指针数组的指针

指向函数指针数组的指针是一个 指针 指针指向一个 数组 ，数组的元素都是 函数指针 ; 如何定义？

void test(const char* str)
{
    printf("%s\n", str);
}
int main()
{
    //函数指针pfun
    void (*pfun)(const char*) = test;
    //函数指针的数组pfunArr
    void (*pfunArr[5])(const char* str);
    pfunArr[0] = test;
    //指向函数指针数组pfunArr的指针ppfunArr
    void (*(*ppfunArr)[5])(const char*) = &pfunArr;
    return 0;
}

24.回调函数

回调函数就是一个通过函数指针调用的函数。如果你把函数的指针（地址）作为参数传递给另一个函数，当这个指针被用来调用其所指向的函数时，我们就说这是回调函数。回调函数不是由该函数的实现方直接调用，而是在特定的事件或条件发生时由另外的一方调用的，用于对该事件或条件进行响应。

25.qsort使用举例

#include <stdlib>

使用快速排序的思想实现的一个排序函数。 qsort可以排序任意类型的数据。

void qsort( void *base, //要排序的数据的起始位置
            size_t num, //待排序的数据元素的个数
            size_t width, //待排序的数据元素的大小（单位：byte）
            int (*cmp )(const void *e1, const void *e2) //函数指针-比较函数
          );

25.1使用qsort函数排序整型数据

#include <stdio.h>
//qosrt函数的使用者得先拿出一个对其想要排序的数据的排序规则的实现函数
int int_cmp(const void * p1, const void * p2)
{
    return (*( int *)p1 - *(int *) p2);
    //这里提供了一个好思路，通过相减的方式来比较两个数字的大小
}

//主函数
int main()
{
    int arr[] = { 1, 3, 5, 7, 9, 2, 4, 6, 8, 0 };
    int i = 0;
    qsort(arr, sizeof(arr) / sizeof(arr[0]), sizeof (int), int_cmp);
    int sz = sizeof(arr) / sizeof(arr[0])；
    for (i = 0; i<sz ; i++)
    {
        printf( "%d ", arr[i]);
    }
    printf("\n");
    return 0;
}

25.2使用qsort排序结构数据

struct Stu //学⽣
{
    char name[20];//名字
    int age;//年龄
};


//假设按照年龄来⽐较
int cmp_stu_by_age(const void* e1, const void* e2)
{
    return ((struct Stu*)e1)->age - ((struct Stu*)e2)->age;
}

//假设按照名字来⽐较
//strcmp - 是库函数，是专⻔⽤来⽐较两个字符串的⼤⼩的
int cmp_stu_by_name(const void* e1, const void* e2)
{
    return strcmp(((struct Stu*)e1)->name, ((struct Stu*)e2)->name);
}

//按照年龄来排序
void test2()
{
    struct Stu s[] = { {"zhangsan", 20}, {"lisi", 30}, {"wangwu", 15} };
    int sz = sizeof(s) / sizeof(s[0]);
    qsort(s, sz, sizeof(s[0]), cmp_stu_by_age);
}

//按照名字来排序
void test3()
{
    struct Stu s[] = { {"zhangsan", 20}, {"lisi", 30}, {"wangwu", 15} };
    int sz = sizeof(s) / sizeof(s[0]);
    qsort(s, sz, sizeof(s[0]), cmp_stu_by_name);
}


int main()
{
    test2();
    test3();
    return 0;
}

25.3 qsort函数的模拟实现

使⽤回调函数，模拟实现qsort(采⽤冒泡的⽅式)。

#include <stdio.h>
int int_cmp(const void * p1, const void * p2)
{
    return (*( int *)p1 - *(int *) p2);
}

void _swap(void *p1, void * p2, int size)
{
    int i = 0;
    for (i = 0; i< size; i++)
    {
        char tmp = *((char *)p1 + i);
        *(( char *)p1 + i) = *((char *) p2 + i);
        *(( char *)p2 + i) = tmp;
    }
}

void bubble(void *base, int count , int size, int(*cmp )(void *e1, void *e2))
{
    int i = 0;
    int j = 0;
    for (i = 0; i< count - 1; i++)
    {
        for (j = 0; j<count-i-1; j++)
        {
            if (cmp ((char *) base + j*size , (char *)base + (j + 1)*size)>0)                        
            {
                _swap(( char *)base + j*size, (char *)base + (j + 1)*size, size);
            }
        }
    }
}

int main()
{
    int arr[] = { 1, 3, 5, 7, 9, 2, 4, 6, 8, 0 };
    //char *arr[] = {"aaaa","dddd","cccc","bbbb"};
    int i = 0;
    bubble(arr, sizeof(arr) / sizeof(arr[0]), sizeof (int), int_cmp);
    for (i = 0; i< sizeof(arr) / sizeof(arr[0]); i++)
    {
        printf( "%d ", arr[i]);
    }
    printf("\n");
    return 0;
}

26. sizeof和strlen的对比

26.1 sizeof()使用

在学习操作符的时候，我们学习了 sizeof ， sizeof 计算变量所占内存内存空间⼤⼩的，单位是字节，如果操作数是类型的话，计算的是使⽤类型创建的变量所占内存空间的⼤⼩。

sizeof 只关注占⽤内存空间的⼤⼩，不在乎内存中存放什么数据。

比如：

#inculde <stdio.h>
int main()
{
    int a = 10;
    printf("%d\n", sizeof(a));
    printf("%d\n", sizeof a);
    printf("%d\n", sizeof(int));
    return 0;
}

26.2 strlen()使用

strlen 是C语⾔库函数，功能是求字符串⻓度。函数原型如下：

size_t strlen ( const char * str );

统计的是从 strlen 函数的参数 str 中这个地址开始向后， \0 之前字符串中字符的个数。 strlen 函数会⼀直向后找 \0 字符，直到找到为止，所以可能存在越界查找。

#include <stdio.h>
int main()
{
    char arr1[3] = {'a', 'b', 'c'};
    char arr2[] = "abc";
    printf("%d\n", strlen(arr1));
    printf("%d\n", strlen(arr2));

    printf("%d\n", sizeof(arr1));
    printf("%d\n", sizeof(arr2));
    return 0;
}

26.3 sizeof()和strlen()的对比

sizeof()

1. sizeof是操作符
2. sizeof计算操作数所占内存的大小，单位是字节
3. 不关注内存中存放什么数据

strlen()

1. strlen是库函数，使⽤需要包含头⽂件string.h
2. srtlen是求字符串长度的，统计的是\0之前字符的隔个数
3. 关注内存中是否有\0,如果没有\0，就会持续往后找，可能会越界

27.数组和指针笔试题解析

27.1⼀维数组

考察对数组名的理解和指针的运算和指针类型的意义

int a[] = {1,2,3,4};
printf("%d\n",sizeof(a));  //16
//sizeof(数组名)，数组名表示整个数组，计算的是整个数组的大小，单位是字节
printf("%d\n",sizeof(a+0));  // 4或8
//a不是单独放在sizeof内部，也没有取地址，a+0表示数组首元素的地址
printf("%d\n",sizeof(*a));   //4
//*a相当于a[0]
printf("%d\n",sizeof(a+1));  // 4或8
//这里的a是数组首元素的地址，a+1是第二个元素的地址
//sizeof(a+1)就是地址的大小
printf("%d\n",sizeof(a[1]));  //4
//计算的是第二个元素的大小
printf("%d\n",sizeof(&a));   // 4或8
//&a取出的数组的地址，数组的地址，也是一个地址
printf("%d\n",sizeof(*&a));  //16
//&a---->int(*)[4]
//&a拿到的是数组名的地址，类型是int(*)[4],是一种数组指针
//数组指针解引用找到的是数组
//*&a--->a
//相当于sizeof(a)
printf("%d\n",sizeof(&a+1));   // 4或8
//&a取出的是数组的地址
//&a--> int(*)[4]
//&a+1是从数组a的地址向后跳过了一个(4个整型元素的)数组的大小
//&a+1还是地址，是地址就是4/8字节
printf("%d\n",sizeof(&a[0]));   // 4或8
//&a[0]就是第一个元素的地址
//计算的是地址的大小
printf("%d\n",sizeof(&a[0]+1));   // 4或8
//&a[0]+1是第二个元素的地址
//大小是4/8个字节
//&a[0]+1--->&a[1]

27.2字符数组

代码1：

char arr[] = {'a','b','c','d','e','f'};
printf("%d\n", sizeof(arr));  //6
printf("%d\n", sizeof(arr+0));  //4或8
printf("%d\n", sizeof(*arr));  //1
//*arr相当于*(arr+0),相当于arr[0];
printf("%d\n", sizeof(arr[1]));  //1
//arr[1]相当于*(arr+1)
printf("%d\n", sizeof(&arr));  //4或8
printf("%d\n", sizeof(&arr+1));  //4或8
printf("%d\n", sizeof(&arr[0]+1));  //4或8

代码2:

char arr[] = {'a','b','c','d','e','f'};
printf("%d\n", strlen(arr));  //不确定(随机值)
printf("%d\n", strlen(arr+0));  //不确定(随机值)
printf("%d\n", strlen(*arr));   //程序出错
//相当于strlen('a');--->strlen(97)，野指针
printf("%d\n", strlen(arr[1]));  //程序出错
//理由同上
printf("%d\n", strlen(&arr));   //不确定(随机值)和arr一样
printf("%d\n", strlen(&arr+1));   //不确定（随机值），比arr少了6
printf("%d\n", strlen(&arr[0]+1)); //不确定（随机值），比arr少了1

代码3：

char arr[] = "abcdef";
printf("%d\n", sizeof(arr));  //7
printf("%d\n", sizeof(arr+0)); //4或8
printf("%d\n", sizeof(*arr));  //1
printf("%d\n", sizeof(arr[1])); //1
printf("%d\n", sizeof(&arr)); //4或8
printf("%d\n", sizeof(&arr+1));  //4或8
printf("%d\n", sizeof(&arr[0]+1));  //4或8

代码4：

char arr[] = "abcdef";
printf("%d\n", strlen(arr)); //6
printf("%d\n", strlen(arr+0)); //6
printf("%d\n", strlen(*arr));  //出问题
printf("%d\n", strlen(arr[1]));  //出问题
printf("%d\n", strlen(&arr));  //6
printf("%d\n", strlen(&arr+1));  //不确定（随机值）
printf("%d\n", strlen(&arr[0]+1)); //5

代码5：

char *p = "abcdef";
printf("%d\n", sizeof(p));   //4或8
printf("%d\n", sizeof(p+1));  //4或8
printf("%d\n", sizeof(*p));   //1
printf("%d\n", sizeof(p[0]));  //1
//p[0]-->*(p+0)-->*p
printf("%d\n", sizeof(&p));   //4或8
printf("%d\n", sizeof(&p+1));   //4或8 
printf("%d\n", sizeof(&p[0]+1));   //4或8

代码6

char *p = "abcdef";
printf("%d\n", strlen(p));  //6
printf("%d\n", strlen(p+1));  //5
printf("%d\n", strlen(*p));  //出问题
printf("%d\n", strlen(p[0]));  //出问题
printf("%d\n", strlen(&p));   //随机值
printf("%d\n", strlen(&p+1));   //随机值（和&p无必然联系）
printf("%d\n", strlen(&p[0]+1));  //5

27.3⼆维数组

int a[3][4] = {0};
printf("%d\n",sizeof(a));   //48
printf("%d\n",sizeof(a[0][0]));  //4
printf("%d\n",sizeof(a[0]));    //16
//a[0]是第一行这个一维数组的数组名，单独放在sizeof内部,
//a[0]表示第一个整个这个一维数组
printf("%d\n",sizeof(a[0]+1));   //4或8
//a[0]并没有单独放在sizeof内部，也没有取地址，a[0]就表示首元素的地址，就是第一行这个一维数组的第一个元素的地址
//a[0]+1就是第一行第二个元素的地址
printf("%d\n",sizeof(*(a[0]+1)));   //4
printf("%d\n",sizeof(a+1));    //4或8
//a虽然是二维数组的地址，但是并没有单独放在sizeof内部，也没取地址。
//a表示首元素的地址，二维数组的首元素是它的第一行
//a就表示第一行的地址，a+1就是跳过第一行，表示第二行的地址
printf("%d\n",sizeof(*(a+1)));   // 16
//*(a+1)-->a[1],相当于sizeof(a[1])
printf("%d\n",sizeof(&a[0]+1));   // 4或8
//&a[0]--->&*(a+0)-->a,所以&a[0]+1--->第二行的地址
printf("%d\n",sizeof(*(&a[0]+1)));  //16
printf("%d\n",sizeof(*a));  //16
printf("%d\n",sizeof(a[3]));  //16

数组名的意义：

1. sizeof(数组名)，这⾥的数组名表⽰整个数组，计算的是整个数组的⼤⼩。
2. &数组名，这⾥的数组名表⽰整个数组，取出的是整个数组的地址。
3. 除此之外所有的数组名都表⽰⾸元素的地址。

如果一个数组名，既没有单独放在sizeof内部，也没有取地址，则这里的数组名表示首元素的地址

28.指针运算笔试题解析

28.1题目一

int main()
{
    int a[5] = {1, 2, 3, 4, 5};
    int *ptr = (int *)(&a + 1);
    printf( "%d,%d", *(a + 1), *(ptr - 1));
    return 0;
}
//程序的结果是什么？ 2,5

28.2题目二

//在X86环境下
//假设结构体的大小是20个字节
//程序输出的结果是啥？
struct Test
{
    int Num;
    char *pcName;
    short sDate;
    char cha[2];
    short sBa[4];
}*p = (struct Test*)0x100000;


int main()
{   
    printf("%p\n", p + 0x1);
    //结构体指针+1相当于地址加上指针的大小
    //0x100000+20-->0x100014
    printf("%p\n", (unsigned long)p + 0x1);
    //0x100001
    printf("%p\n", (unsigned int*)p + 0x1);
    //0x100004
    return 0;
}

28.3题目三

#include <stdio.h>
int main()
{
    int a[3][2] = { (0, 1), (2, 3), (4, 5) };
    int *p;
    p = a[0];
    printf( "%d", p[0]);
    return 0;
}

28.4题目四

//假设环境是x86环境，程序输出的结果是啥？
#include <stdio.h>
int main()
{
    int a[5][5];
    int(*p)[4];
    p = a;
    printf( "%p,%d\n", &p[4][2] - &a[4][2], &p[4][2] - &a[4][2]);
    return 0;
}

28.5题目五

#include <stdio.h>
int main()
{
    int aa[2][5] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
    int *ptr1 = (int *)(&aa + 1);
    int *ptr2 = (int *)(*(aa + 1));
    printf( "%d,%d", *(ptr1 - 1), *(ptr2 - 1));
    return 0;
}

输出:10,

28.6题目六

#include <stdio.h>
int main()
{
    char *a[] = {"work","at","alibaba"};
    char**pa = a;
    pa++;
    printf("%s\n", *pa);
    return 0;
}

28.7题目七

#include <stdio.h>
int main()
{
    char  *c[] = {"ENTER","NEW","POINT","FIRST"};
    char **cp[] = {c+3,c+2,c+1,c};
    char ***cpp = cp;
    printf("%s\n", **++cpp);
    printf("%s\n", *--*++cpp+3);
    printf("%s\n", *cpp[-2]+3);
    printf("%s\n", cpp[-1][-1]+1);
    return 0;
}

28.8题目八

int main()
{
    int a[4] = { 1, 2, 3, 4 };
    int *ptr1 = (int *)(&a + 1);
    int *ptr2 = (int *)((int)a + 1);
    printf( "%x,%x", ptr1[-1], *ptr2);
    return 0;
}

十一、自定义类型详解

• 结构体

1. 结构体类型的声明
2. 结构的自引用
3. 结构体变量的定义和初始化
4. 结构体内存对齐
5. 结构体传参
6. 结构体实现位段（位段的填充&可移植性）

• 枚举

1. 枚举类型的定义
2. 枚举的优点
3. 枚举的使用

• 联合

1. 联合类型的定义
2. 联合的特点
3. 联合大小的计算

1.结构体struct

1.1结构体类型的声明

1.1.1结构的基础知识

结构是一些值的集合，这些值称为成员变量。结构的每个成员可以是不同类型的变量。

而数组是一组相同类型的元素集合，复杂对象的描述需要使用结构体

1.1.2结构的声明

struct tag
{
    member-list;
}(variable-list);

例如描述一个学生：

struct Stu
{
    char name[20];//名字
    int age;//年龄
    char sex[6];//性别
    char id[20];//学号
}p1,p2;//分号不能丢

这里的p1和p2就是通过Stu这个结构体创建的两个变量,注意它们是全局的结构体变量。

1.1.3结构成员的类型

结构的成员可以是标量、数组、指针，甚至是其他结构体。

1.1.4结构体变量的定义和初始化

有了结构体类型，那如何定义变量，其实很简单。

struct Point
{
    int x;
    int y;
}p1; //声明类型的同时定义变量p1

struct Point
{
    int x;
    int y;
}


int main()
{
    struct Point p2,p3,p4; 
    //定义结构体变量p2,这些都是全局的结构体变量
    struct Point p3 = {x, y}; 
    //初始化：定义变量的同时赋初值。
}

struct Stu           //类型声明
{
    char name[15];   //名字
    int age;         //年龄
};
struct Stu s = {"zhangsan", 20};//初始化

struct Node
{
    int data;
    struct Point p;
    struct Node* next; 
}n1 = {10, {4,5}, NULL}; 
//结构体嵌套初始化

struct Node n2 = {20, {5, 6}, NULL};
//结构体嵌套初始化

1.1.5特殊的声明

在声明结构的时候，可以不完全的声明。

比如：

//匿名结构体类型
struct
{
    int a;
    char b;
    float c;
}x;

struct
{
    int a;
    char b;
    float c;
}a[20], *p;

上面的两个结构在声明的时候省略掉了结构体标签（tag）。
那么问题来了？

//在上面代码的基础上，下面的代码合法吗？
p = &x;

警告：
编译器会把上面的两个声明当成完全不同的两个类型。
所以是非法的

1.1.6 结构的自引用

在结构中包含一个类型为该结构本身的成员是否可以呢？

//代码1
struct Node
{
    int data;
    struct Node next;
};
//可行否？
如果可以，那sizeof(struct Node)是多少？

正确的自引用方式：

//代码2
struct Node
{
    int data;
    struct Node* next;
};

注意：

//代码3
typedef struct
{
    int data;
    Node* next;
}Node;

//这样写代码，可行否？
//解决方案：

typedef struct Node
{
    int data;
    struct Node* next;
}Node;

2.结构体成员的访问

• 结构体变量访问成员
  结构变量的成员是通过点操作符（.）访问的。点操作符接受两个操作数。

struct Stu s;
strcpy(s.name, "zhangsan");//使用.访问name成员
s.age = 20;//使用.访问age成员

• 结构体指针访问指向变量的成员 有时候我们得到的不是一个结构体变量，而是指向一个结构体的指针。这时使用"->"

struct Stu
{
    char name[20];
    int age;
};

void print(struct Stu* ps)
{
    printf("name = %s   age = %d\n", (*ps).name, (*ps).age);

    //使用结构体指针访问指向对象的成员
    printf("name = %s   age = %d\n", ps->name, ps->age);
}

int main()
{
    struct Stu s = {"zhangsan", 20};
    print(&s);
    //结构体地址传参
    return 0;
}

3.结构体传参

struct S
{
    int data[1000];
    int num;
};

struct S s = {{1,2,3,4}, 1000};//创建结构体变量


//结构体传参
void print1(struct S s)
{
    printf("%d\n", s.num);
}
//结构体地址传参
void print2(struct S* ps)
{
    printf("%d\n", ps->num);
}
int main()
{
    print1(s);  //传结构体
    print2(&s); //传地址
    return 0;
}

上面的 print1 和 print2 函数哪个好些？ 答案是：首选print2函数。

函数传参的时候，参数是需要压栈的。 如果传递一个结构体对象的时候，结构体过大，参数压栈的系统开销比较大，所以会导致性能的下降。

结论：结构体传参的时候，要传结构体的地址。

举例:

//step1:打印结构体信息(此时并不占用内存)
struct Stu
{
    //结构成员
    char name[20];//数组
    int age;
    char sex[10];//数组
    char phoneNum[12];//数组
};   //这个";"不可少,用于隔开

int main()
{
    struct Stu s = {"zhangsan",20,"nan","123456"};
    //step2:初始化结构体
    printf("%s %d %s %s\n",s.name, s.age, s.sex, s.phoneNum);
    //'.'为结构成员访问操作符
    //使用方法:结构体对象.成员名
}

以上代码可以用指针替换实现,

struct Stu
{
    char name[20];
    int age;
    char sex[10];
    char phoneNum[12];
};   

void print(struct Stu* ps)
{
    printf("%s %d %s %s\n",(*ps).name, (*ps).age, (*ps).sex, (*ps).phoneNum);
    printf("%s %d %s %s\n",ps->name, ps->age, ps->sex, ps->phoneNum);
    //用法:结构体指针变量->成员名
}

int main()
{
    struct Stu s = {"zhangsan",20,"nan","123456"};
    print(&s);
}

十二、实用调试技巧

1.什么是调试

当我们发现程序中存在的问题的时候，那下一步就是找到问题，并修复问题。这个找问题的过程叫称为调试，英文叫debug（消灭bug）的意思。

调试一个程序，首先是承认出现了问题，然后通过各种手段去定位问题的位置，可能是逐过程的调试，也可能是隔离和屏蔽代码的方式，找到问题所的位置，然后确定错误产生的原因，再修复代码，重新测试。

2.Debug和Release

Debug 通常称为调试版本，它包含调试信息，并且不作任何优化，便于程序员调试程序；程序员在写代码的时候，需要经常性的调试代码，就将这里设置为debug ，这样编译产生的是debug 版本的可执行程序，其中包含调试信息，是可以直接调试的。

Release 称为发布版本，它往往是进行了各种优化，使得程序在代码大小和运行速度上都是最优的，以便用户很好地使用。当程序员写完代码，测试再对程序进行测试，直到程序的质量符合交付给用户使用的标准，这个时候就会设置为release ，编译产生的就是release 版本的可执行程序，这个版本是用户使用的，无需包含调试信息等。

对比可以看到从同一段代码，编译生成的可执行文件的大小，release版本明显要小，而debug版本明显大。

3.VS调试快捷键

3.1环境准备

首先是环境的准备，需要一个支持调试的开发环境，我们上课使用VS，应该把VS上设置为Debug。

3.2调试快捷键

F9：创建断点和取消断点
断点的作用是可以在程序的任意位置设置断点，打上断点就可以使得程序执行到想要的位置暂定执行，接下来我们就可以使用F10，F11这些快捷键，观察代码的执行细节。

条件断点：满足这个条件，才触发断点

F5：启动调试，经常用来直接跳到下一个断点处，一般是 和F9配合使用。

F10：逐过程，通常用来处理一个过程，一个过程可以是一次函数调用，或者是一条语句。

F11：逐语句，就是每次都执行一条语句，但是这个快捷键可以使我们的执行逻辑进入函数内部。在函数调用的地方，想进入函数观察细节，必须使用F11，如果使用F10，直接完成函数调用。

CTRL + F5：开始执行不调试，如果你想让程序直接运行起来而不调试就可以直接使用。

4.监视和内存观察

在调试的过程中我们，如果要观察代码执行过程中，上下文环境中的变量的值，有哪些方法呢？

这些观察的前提条件一定是开始调试后观察，比如：

#include <stdio.h>
int main()
{
    int arr[10] = { 0 };
    int num = 100;
    char c = 'w';
    int i = 0;
    for (i = 0; i < 10; i++)
    {
        arr[i] = i;
    }
    return 0;
}

4.1监视

开始调试后，在菜单栏中【调试】->【窗口】->【监视】，打开任意一个监视窗口，输入想要观察的对象就行。

打开监视窗口,并在监视窗口中观察。

4.2内存

如果监视窗口看的不够仔细，也是可以观察变量在内存中的存储情况，还是在【调试】->【窗口】->【内存】

打开内存窗口，在打开内存窗口后，要在地址栏输入：arr，&num，&c，这类地址，就能观察到该地址处的数据。除此之外，在调试的窗口中还有：自动窗口，局部变量，反汇编、寄存器等窗口。

5.调试举例

5.1举例一：阶乘累加

求1!+2!+3!+4!+...10! 的和，请看下面的代码：

#include <stdio.h>
//写一个代码求n的阶乘
int main()
{
    int n = 0;
    scanf("%d", &n);
    int i = 1;
    int ret = 1;
    for(i=1; i<=n; i++)
    {
        ret *= i;
    }
    printf("%d\n", ret);
    return 0;
}

如果n分别是1,2,3,4,5...10,求出每个数的阶乘，再求和就好了,在上面的代码上改造:

int main()
{
    int n = 0;
    int i = 1;
    int sum = 0;
    for(n=1; n<=10; n++)
    {
        for(i=1; i<=n; i++)
        {
            ret *= i;
        }
        sum += ret;
    }
    printf("%d\n", sum);
    return 0;
}
//运行结果应该是错的？

调试找一下问题。ret未置1

5.2举例二：一个奇怪的代码

在VS2022、X86、Debug 的环境下，编译器不做任何优化的话，下面代码执行的结果是啥？

#include <stdio.h>
int main()
{
    int i = 0;
    int arr[10] = {1,2,3,4,5,6,7,8,9,10};
    for(i=0; i<=12; i++)
    {
        arr[i] = 0;
        printf("hehe\n");
    }
    return 0;
}

程序运行，死循环了，调试看看为什么？
调试可以上面程序的内存布局如下：

知识点：

1. 栈区内存的使用习惯是从高地址向低地址使用的，所以变量i的地址是较大的。arr数组的地址整体是小于i的地址。
2. 数组在内存中的存放是：随着下标的增长，地址是由低到高变化的。所以根据代码，就能理解为什么是左边的代码布局了。

如果是上面的内存布局，那随着数组下标的增长，往后越界就有可能覆盖到i，这样就可能造成死循环的。

这里肯定有同学有疑问：为什么i和arr数组之间恰好空出来2个整型的空间呢？这里确实是巧合，在不同的编译器下可能中间的空出的空间大小是不一样的，代码中这些变量内存的分配和地址分配是编译器指定的，所以的不同的编译器之间就有差异了。所以这个题目是和环境相关的。

注意：栈区的默认的使用习惯是先使用高地址，再使用低地址的空间，但是这个具体还是要编译器的实现.

比如：
在VS上切换到X64，这个使用的顺序就是相反的，在Release版本的程序中，这个使用的顺序也是相反的。

5.3举例三：扫雷实践

如果一个代码稍微复杂，那怎么调试呢？ 这里我们就上手调试一下扫雷的代码。
演示：

• 在函数内部打断点，快速跳转到函数
• 在数组传参，调试进入函数，如何在监视窗口观察数组的内容： 数组名,n 的形式

调试过程中，要做到心中有数，也就是程序员自己心里要清晰的知道希望代码怎么执行，然后再去看代码有没有按照我们预定的路线在执行。 调试是需要反复去动手练习的，调试是可以增加程序员对代码的理解和掌控的，掌握了调试的能力，就能看到本质，就像能给程序做B超一样，对程序内部一览无余。

6.编程常见错误归类

6.1编译型错误

直接看错误提示信息（双击），解决问题。或者凭借经验就可以搞定。相对来说简单。（不符合语法规则）

6.2链接型错误

看错误提示信息，主要在代码中找到错误信息中的标识符，然后定位问题所在。一般是标识符名不存在或者拼写错误。

6.3运行时错误

结果不是程序员想要的。

借助调试，逐步定位问题。最难搞。

7.写代码好习惯

7.1优秀的代码

1. 代码运行正常
2. bug很少
3. 效率高
4. 可读性高
5. 可维护性高
6. 注释清晰
7. 文档齐全

常见的coding技巧：

1. 使用assert
2. 尽量使用const
3. 养成良好的编码风格
4. 添加必要的注释
5. 避免编码的陷阱。

7.2示范

/***
*char *strcpy(dst, src) - copy one string over another
*
*Purpose:
* Copies the string src into the spot specified by
* dest; assumes enough room.
*
*Entry:
* char * dst - string over which "src" is to be copied
* const char * src - string to be copied over "dst"
*
*Exit:
* The address of "dst"
*
*Exceptions:
*******************************************************************************/
char * strcpy(char * dst, const char * src)
{
    char * cp = dst;
    assert(dst && src);
    while( *cp++ = *src++ )
        ; /* Copy src over dst */
    return( dst );
}

十三、数据在内存中的存储

*数据类型复习

char -1//字符数据类型
short -2 //短整型
int -4 //整型
long -4 //长整型
long long -8//更长的整型
float -4//单精度浮点数
double -8//双精度浮点数
long double -16

以及他们所占存储空间的大小。
类型的意义：

1. 使用这个类型开辟内存空间的大小（大小决定了使用范围）。
2. 如何看待内存空间的视角。

类型的基本归类

整形家族

char//字符的本质是ASCLL码值
    char//标准未定义
    unsigned char
    signed char
short
    unsigned short [int]
    signed short [int]
int
    unsigned int
    signed int
long
    unsigned long [int]
    signed long [int]

浮点数家族

float
double

构造类型

数组类型
结构体类型 struct
枚举类型 enum
联合类型 union

指针类型

int *pi;
char *pc;
float* pf;
void* pv;

空类型

void 表示空类型（无类型）
通常应用于函数的返回类型、函数的参数、指针类型。

*（准备知识）原码、反码和补码

1.机器数

一个数在计算机中的表示形式是二进制的话，这个数其实就叫机器数。

机器数通常是带有符号的（指有正数和负数之分），计算机用最高位存放符号，这个 bit 一般叫做符号位。 正数的符号位为 0， 负数的符号位为 1。比如，十进制中的数 +7 ，计算机字长为8位，转换成二进制就是 0 0 0 0 0 1 1 1（一个 byte 有 8bit，有效的取值范围是 -128 ~ +127）。

如果是 -7 ，就是 1 0 0 0 0 1 1 1 。一个存储的二进制码分原码、反码、补码。

2.原码

十进制数据的二进制表现形式就是原码，原码最左边的一个数字就是符号位，0为正，1为负。

例如：56 -> 0 0 1 1 1 0 0 0

左边第一位为符号位，其他位为数据位。

一个 byte 有 8bit，最大值是 0 1 1 1 1 1 1 1 (+127)，最小值是 1 1 1 1 1 1 1 1 (-128)

在计算机中之所以使用二进制来表示原码是因为逻辑简单，对于电路来说只有开或者关两种状态，用二进制是在方便不过的了。如果使用的进制是十进制、八进制或者十六进制的话，电路没有办法表示那么多的状态。

• 正数计算

使用原码对正数进行计算不会有任何问题的
例如：5+2

 0 0 0 0 0 1 0 1
+        0 0 1 0
-----------------
 0 0 0 0 0 1 1 1
把这个结果转成十进制就等于7

• 负数计算

但是如果是负数的话，那计算的结果就会大相径庭了

我们拿 -56 这个数字来举例，它的原码是 1 0 1 1 1 0 0 0 ，减一之后，就会变成 1 0 1 1 0 1 1 1 ，这个数转成十进制就是 -55。计算前是 -56，减一之后正确的结果应该是 -57（1 0 1 1 1 0 0 1）才对，居然还越减越大了。

 1 0 1 1 1 0 0 0
-              1
-----------------
 1 0 1 1 0 1 1 1

为了解决原码不能用于计算负数的这种问题，这时候，反码它出现了，作为负数的“计算的救星”。

计算规则是正数的反码不变和原码一致，负数的反码会在原码的基础上，高位的符号位不变，其他位取反（ 1 变成 0 ， 0 变为 1 ）。

3.反码

正数的反码是其本身（等于原码），负数的反码是符号位保持不变，其余位取反。

反码的存在是为了正确计算负数，因为原码不能用于计算负数。

• 负数计算 这时候，我们再来使用反码计算一下 -56 - 1 的结果

-56 的原码是 1 0 1 1 1 0 0 0 ，如果转成反码（符号位不变，其他位取反），

那么它的反码就是 1 1 0 0 0 1 1 1

• 跨零计算

不过反码也有它的 “ 软肋 ”，如果是负数跨零进行计算的话，计算得出的结果不对

我们拿 -3 + 5 来举例

-3 的原码是 1 0 0 0 0 0 1 1，转成反码的话就是 1 1 1 1 1 1 0 0

 1 1 1 1 1 1 0 0
+        0 1 0 1  
-----------------
 0 0 0 0 0 0 0 1 

把计算结果转成十进制就是 1，这结果显然不对。那么我们该怎么计算呢，这时候，作为反码的补充编码 —— 补码就出现了。

4.补码

正数的补码是其本身，负数的补码等于其反码 +1。因为反码不能解决负数跨零（类似于 -6 + 7）的问题，所以补码出现了。

• 跨零计算

这时候，我们再来使用补码计算一下 -3 + 5 的结果

-3 的原码是 1 0 0 0 0 0 1 1，转成反码的话就是 1 1 1 1 1 1 0 0，再转成补码就是 1 1 1 1 1 1 0 1

 1 1 1 1 1 1 0 1
+        0 1 0 1
----------------- 
 0 0 0 0 0 0 1 0

把这个数转成十进制刚好等于2，结果正确

5.总结

在计算机当中都是使用补码来进行计算和存储的。补码很好的解决了反码负数不能跨零计算的弊端，并且补码还可以记录一个特殊的值 -128，这个数据在 1 个字节下是没有原码和反码。

学习了原码、反码和补码的知识之后，我们就可以了解到，Java 当中所有的基本数据类型。比如整数类型的数据类型，存储的数都是同样的，区别是在于什么地方，假设存储的值都是 10。

6.类型转换原理

• 隐式类型转换

public class Test {
	public static void main(String[] args) {
    	// 小的数据类型往大的数据类型进行转换底层就是通过左补零完成的
        byte a = 10; // 0000 1010
        int b = a;	 // 0000 0000 0000 0000 0000 0000 0000 1010
        System.out.println(b);
    }
}

• 强制类型转换

public class Test {
	public static void main(String[] args) {
    	int a = 300;	   		
// 0000 0000 0000 0000 0000 0001 0010 1100
        byte b = (byte) a; 		
// 0010 1100
        System.out.println(b);	// 打印出44
        /*
        	int a = 200;	  		
            // 0000 0000 0000 0000 0000 0000 1100 1000
        	byte b = (byte)a; // 1100 1000
        	System.out.println(b);// 打印出-56
        */
    }
}

7.换算

• 正数:
  正整数的原码、反码和补码是一样的。 即看到符号位（第一位）是0，就可以照着写出其他两种码。

• 负数：

1. 原码转换为反码：符号位不变，数值位分别“按位取反”
2. 反码转换为原码也是一样：符号位不变，数值位分别“按位取反”
3. 原码转换为补码：符号位不变，数值位按位取反,末位再加1
4. 补码转换为原码：符号位不变，数值位按位取反,末位再加1 (即补码的补码等于原码)
5. 求补(变补)，即已知[X]补，求[-X]补。符号位和数值位都取反，末位再加1

1.整数在内存中的存储

对于整形来说：数据存放内存中其实存放的是补码。

为什么呢？

在计算机系统中，数值一律用补码来表示和存储。 原因在于，使用补码，可以将符号位和数值域统一处理； 同时，加法和减法也可以统一处理（CPU只有加法器）此外，补码与原码相互转换，其运算过程是相同的，不需要额外的硬件电路。

2.大小端字节序和字节序判断

当我们了解了整数在内存中存储后，我们调试看一个细节：

#include <stdio.h>
int main()
{
    int a = 0x11223344;
    return 0;
}

调试的时候，我们可以看到在a中的0x11223344 这个数字是按照字节为单位，倒着存储的。这是为什么呢？

2.1什么是大小端

其实超过一个字节的数据在内存中存储的时候，就有存储顺序的问题，按照不同的存储顺序，我们分为大端字节序存储和小端字节序存储,下面是具体的概念：

大端（存储）模式：

是指数据的低位字节内容保存在内存的高地址处，而数据的高位字节内容，保存在内存的低地址处。

小端（存储）模式：

是指数据的低位字节内容保存在内存的低地址处，而数据的高位字节内容，保存在内存的高地址处。

上述概念需要记住，方便分辨大小端。

2.2为什么会有大小端

为什么会有大小端模式之分呢？

这是因为在计算机系统中，我们是以字节为单位的，每个地址单元都对应着一个字节，一个字节为8bit 位，但是在C语言中除了8 bit 的char 之外，还有16 bit 的short 型，32 bit 的long 型（要看 具体的编译器），另外，对于位数大于8位的处理器，例如16位或者32位的处理器，由于寄存器宽度大于一个字节，那么必然存在着一个如何将多个字节安排的问题。因此就导致了大端存储模式和小端存储模式。

例如：一个16bit 的short 型x ，在内存中的地址为0x0010 ， x 的值为0x1122 ，那么0x11 为高字节， 0x22 为低字节。对于大端模式，就将0x11 放在低地址中，即0x0010 中，0x22 放在高地址中，即0x0011 中。小端模式，刚好相反。我们常用的X86 结构是小端模式，而KEIL C51 则为大端模式。很多的ARM，DSP都为小端模式。有些ARM处理器还可以由硬件来选择是大端模式还是小端模式。

2.3练习

2.3.1设计程序判断大小端

请简述大端字节序和小端字节序的概念，设计一个小程序来判断当前机器的字节序。（10分）-百度笔试题

//代码1
#include <stdio.h>
int check_sys()
{
    int i = 1;
    return (*(char *)&i);
}

int main()
{
    int ret = check_sys();
    if(ret == 1)
    {
        printf("小端\n");
    }
    else
    {
        printf("大端\n");
    }
    return 0;
}

//代码2
int check_sys()
{
    union
    {
        int i;
        char c;
    }un;
    un.i = 1;
    return un.c;
}

2.3.2截断和整型提升

#include <stdio.h>
int main()
{
    char a= -1;
    signed char b=-1;
    unsigned char c=-1;
    printf("a=%d,b=%d,c=%d",a,b,c);
    return 0;
}

输出结果为： -1，-1，255

截断 将占用字节数较多的变量赋值给占用字节数较少的变量时，如将long（16个字节）赋值给int（4个字节）时，这时候long类型的比特位，只将最低的8位赋给了char类型的变量，而高位比特位全部被“截断”；

整型提升 整型提升 是 C程序设计语言 中的一项规定：在表达式计算时，各种整型首先要提升为int类型，如果int类型不足以表示则要提升为unsigned int类型；然后执行表达式的运算。

• 高数据类型向低数据类型转化时会发生截断；

• 低数据类型向高数据类型转化unsigned优先【如图】，或者进行运算时不满足int时会发生整形提升；

2.3.3练习3

#include <stdio.h>
int main()
{
    char a = 128;
    printf("%u\n",a);
    return 0;
}

2.3.4练习

int i= -20;
unsigned int j = 10;
printf("%d\n", i+j);
//按照补码的形式进行运算，最后格式化成为有符号整数

2.3.5练习

unsigned int i;
for(i = 9; i >= 0; i--)
{
    printf("%u\n",i);
}

2.3.6练习

int main()
{
    char a[1000];
    int i;
    for(i=0; i<1000; i++)
    {
        a[i] = -1-i;
    }
    printf("%d",strlen(a));
    return 0;
}

2.3.7练习

#include <stdio.h>
unsigned char i = 0;
int main()
{
    for(i = 0;i<=255;i++)
    {
        printf("hello world\n");
    }
    return 0;
}

3.浮点数在内存中的存储

常见的浮点数：3.14159、1E10等，浮点数家族包括： float、double、long double 类型。

浮点数表示的范围：float.h 中定义

3.1练习

#include <stdio.h>
int main()
{
    int n = 9;
    float *pFloat = (float *)&n;
    printf("n的值为：%d\n",n);
    printf("*pFloat的值为：%f\n",*pFloat);
    *pFloat = 9.0;
    printf("num的值为：%d\n",n);
    printf("*pFloat的值为：%f\n",*pFloat);
    return 0;
}

输出什么？

3.2浮点数的存储

上面的代码中， num 和*pFloat 在内存中明明是同一个数，为什么浮点数和整数的解读结果会差别这么大？

要理解这个结果，一定要搞懂浮点数在计算机内部的表示方法。 根据国际标准IEEE（电气和电子工程协会） 754，任意一个二进制浮点数V可以表示成下面的形式：

V = (−1)S ∗M ∗ 2E

• (−1)S 表示符号位，当S=0，V为正数；当S=1，V为负数 • M 表示有效数字，M是大于等于1，小于2的 • 2E 表示指数位

举例来说： 十进制的5.0，写成二进制是101.0 ，相当于1.01×2^2 。

那么，按照上面V的格式，可以得出S=0，M=1.01，E=2。 十进制的-5.0，写成二进制是-101.0 ，相当于-1.01×2^2 。那么，S=1，M=1.01，E=2。

IEEE 754规定：

• 对于32位的浮点数，最高的1位存储符号位S，接着的8位存储指数E，剩下的23位存储有效数字M
• 对于64位的浮点数，最高的1位存储符号位S，接着的11位存储指数E，剩下的52位存储有效数字M

3.2.1浮点数的存储过程

IEEE 754 对有效数字M和指数E，还有一些特别规定。
前面说过， 1≤M<2 ，也就是说，M可以写成1.xxxxxx 的形式，其中xxxxxx 表示小数部分。IEEE 754 规定，在计算机内部保存M时，默认这个数的第一位总是1，因此可以被舍去，只保存后面的 xxxxxx部分。

比如保存1.01的时候，只保存01，等到读取的时候，再把第一位的1加上去。这样做的目的，是节省1位有效数字。以32位浮点数为例，留给M只有23位，将第一位的1舍去以后，等于可以保 存24位有效数字。

至于指数E，情况就比较复杂.
首先，E为一个无符号整数（unsigned int）

这意味着，如果E为8位，它的取值范围为0255；如果E为11位，它的取值范围为02047。但是，我们知道，科学计数法中的E是可以出现负数的，所以IEEE 754规定，存入内存时E的真实值必须再加上一个中间数，对于8位的E，这个中间数是127；对于11位的E，这个中间数是1023。比如，2^10的E是10，所以保存成32位浮点数时，必须保存成10+127=137，即10001001。

3.2.2浮点数的取出过程

指数E从内存中取出还可以再分成三种情况：

E不全为0或不全为1

这时，浮点数就采用下面的规则表示，即指数E的计算值减去127（或1023），得到真实值，再将有效数字M前加上第一位的1。 比如：0.5 的二进制形式为0.1，由于规定正数部分必须为1，即将小数点右移1位，则为1.0*2^(-1)，其阶码为-1+127(中间值)=126，表示为01111110，而尾数1.0去掉整数部分为0，补齐0到23位00000000000000000000000，则其二进制表示形式为:

0 01111110 00000000000000000000000

E全为0 这时，浮点数的指数E等于1-127（或者1-1023）即为真实值，有效数字M不再加上第一位的1，而是还原为0.xxxxxx的小数。这样做是为了表示±0，以及接近于0的很小的数字。

0 00000000 00100000000000000000000

E全为1 这时，如果有效数字M全为0，表示±无穷大（正负取决于符号位s）；

0 11111111 00010000000000000000000

好了，关于浮点数的表示规则，就说到这里。

3.3题目解析

下面，让我们回到一开始的练习
先看第1环节，为什么9 还原成浮点数，就成了0.000000 ？
9以整型的形式存储在内存中，得到如下二进制序列：

0000 0000 0000 0000 1 0000 0000 0000 1001

首先，将9 的二进制序列按照浮点数的形式拆分，得到第一位符号位s=0，后面8位的指数E=00000000 ， 最后23位的有效数字M=000 0000 0000 0000 0000 1001。 由于指数E全为0，所以符合E为全0的情况。因此，浮点数V就写成：

V=(-1)^0 × 0.00000000000000000001001×2^(-126)=1.001×2^(-146)

显然，V是一个很小的接近于0的正数，所以用十进制小数表示就是0.000000。再看第2环节，浮点数9.0，为什么整数打印是1091567616首先，浮点数9.0 等于二进制的1001.0，即换算成科学计数法是：1.001×2^3所以： 9.0 = (−1)0 ∗ (1.001) ∗ 23 ，那么，第一位的符号位S=0，有效数字M等于001后面再加20个0，凑满23位，指数E等于3+127=130，即10000010.所以，写成二进制形式，应该是S+E+M，即

0 10000010 001 0000 0000 0000 0000 0000

这个32位的二进制数，被当做整数来解析的时候，就是整数在内存中的补码，原码正是1091567616。

十四、函数栈帧的深度剖析

局部变量是怎么创建的？ 为什么局部变量的值是随机值？ 函数是怎么传参的？传参的顺序怎么样？ 形参和实参是什么关系？ 函数调用是怎么做的? 函数调用结束后是怎么返回的？

14.1铺垫

在学习函数栈帧前先要进行一点知识铺垫，这样会有助于我们后面对函数栈帧的理解

14.1.1何为函数栈帧

函数栈帧是在内存中的栈区为被调函数开辟的一块空间，里面用来存放该函数中定义的变量等东西（下文会详细讲到），当函数运行完毕栈帧将被销毁。再向大家介绍一下“栈”这个概念，“栈”实际上时一种数据结构，它是一种先进后出的数据表,对栈常见的操作有两种：

Push（入栈）：为栈增加一个元素，就相当于往水池里放盘子
Pop （出栈）： 从栈中取出一个元素，相当于洗完一个盘子把这个洗过的盘子从水池中拿出来

14.1.2寄存器

• eax：是"累加器"(accumulator), 用来存放函数的返回值。
• ebx：是"基地址"(base)寄存器,可作为储存器指针来使用， 在内存寻址时存放基地址。
• ecx： 是计数器(counter), 在循环和指针操作时，要用它来控制循环次数。
• edx：是"数据寄存器’，在进行乘、除法运算时，可作为默认的操作数参数参与运算。
• ebp和esp：他俩都是指针寄存器它最经常被用作高级语言函数调用的"框架指针"(frame pointer)，简单来说这两个寄存器中存放的是地址，这两个地址是用来维护函数栈帧的。
  ebp：存放栈底的地址（指向栈底）
  esp：存放栈顶的地址（指向栈顶）
• edi和esi：它俩都是变址寄存器 ，常用来配合使用完成数据的赋值操作

14.1.3汇编指令

• move：move A,B (将数据B移到数据A)
• push：压栈（入栈）
• pop：出栈
• call：调用函数
• add：加法
• sub：减法
• rep： 重复
• lea：加载有效地址

14.1.4每一个函数调用都要创建函数栈帧

所有的函数调用都会在内存里面的栈区创建函数栈帧，包括main函数。通过上面对函数栈帧的介绍我们知道，函数栈帧是为被调函数在内存的栈区中开辟的一块空间，所以这里间接证明了，main函数也是被调函数。可能很多小伙伴的认知都停留在，main函数是主函数，可以在main函数中调用其他函数，从来没有想过main函数其实也是被调用的。

14.2函数栈帧的创建与销毁详解

14.2.1：main函数也是被调用的

首先点击F10进行调试，在窗口界面找到“调用堆栈”，点击，调出此窗口，此时我们就能很直观的看出main函数是被调用的。
调试结束后我们发现main 函数被__tmainCRTStartup这个函数调用。

14.2.2main函数的函数栈帧的创建与销毁

第一步：push ebp
第二步：move ebp,esp
第三步：sub esp,0E4h
第四步：3个push
第五步：lea加载有效地址
第六步：把main函数里面的空间全初始化
第七步：main函数中变量的创建
1：变量a的创建
2：变量b的创建
3：变量c的创建

由于main函数是被其他函数所调用，所以在 __tmainCRTStartup 这个函数调用main函数的时候会为main函数在内存的栈区中开辟空间：

栈区的使用习惯是先使用高地址再使用低地址，在顶上往进放数据

第一步push ebp

通过上图可以看出第一步是push ebp，这是因为mian函数是被__tmainCRTStartup 这个函数调用的，在调用main函数之前，esp和ebp分别指向__tmainCRTStartup 函数的栈顶和栈底，当调用main函数的时候，就要为main函数开辟相应的函数栈帧，此时esp和ebp就需要移动去指向main函数的函数栈帧。那这里的第一步就是push ebp，

push ebp就是把__mainCRTStartup 函数栈底的地址压栈，ebp的值压入后，esp指针会上移一位。

如上图，再push ebp没有执行的时候，esp里面存的地址是0x0037fdb8，当执行完push ebp后，esp存的地址变成了0x0037fdb4，可见地址减小了4，这就意味着esp指针往上走了4个字节。通过内存窗口我们也可以很容易看出：

此时esp所指向的地址里面存的数据就是ebp所指向的地址0037fe04，说明此时我们已经成功地把ebp所指向的地址压入栈中。

第二步：move ebp,esp

move ebp,esp的意思是：把esp的值给ebp。
esp当前的值是0x0037fdb4，也就是说esp此时指向0x0037fdb4这个地址，把esp的值给ebp后，ebp就也指向0x0037fdb4这个地址

第三步：sub esp,0E4h

sub esp,0ECh,就是给esp减去一个0E4h。这里的0E4h是一个十六进制的数字（h表示是十六进制），0E4对应的10进制数字就是228。这也就意味着esp指向的地址会减小228，对应图示就是esp指针会上移228个字节。

多出来的这一块空间就是为main函数申请的空间

第四步：3个push

执行完push ebx后，esp指向的地址减小了4个字节（从0037FCD0变到00F37CCC,前者比后者大4）。此时esp所指向的地址里面存储的就是ebx的值005c200，这说明ebx成功压栈。剩下的两个push esi和push edi也是这样入栈，

第五步：lea加载有效地址

lea是load effective address（加载有效地址）的缩写。而 lea edi,[ebp-0E4h]的意思就是把ebp-0E4h这个地址放到edi里面。还记得第二步move ebp,esp嘛？。执行完第二步后ebp和esp指向了同一个地址，然后第三步sub esp,0E4h，让esp指向的地址减了0E4h（228），，此后ebp指向的地址没有发生任何变化，第四步的3个push操作让esp指向的地址又减小了12（一次push减小4，3次push就减小12）。而当前的第五步中的地址ebp-0E4h也就是在执行完第三步后esp所指向的地址，就是要把这个地址放到edi里面（其实就是让edi指向这个地址，因为edi是一个变址寄存器，用存储地址的）如下图：

第六步：把main函数里面的空间全初始化

执行完lea后，我们来看下面这三行汇编指令，这三行汇编指令放在一起只为了执行一件事情，所以把这三条指令放在一起看。（分别标上序号1 ， 2 ，3如下图所示：）

• 序号1指令中的ecx是一个计数器，该指令完成的操作是把39h（39h是十六进制数，对应十进制数57）存到ecx里。
• 序号2指令完成的操作是把CCCCCCCC存到eax里。
• 序号3指令中rep的目的是重复其上面的指令，而重复的次数就是ecx存的值，stos的目的是把eax中的值拷贝到es：[edi]所指向的地址里面。一个word代表两个字节，dword其实就是double word的缩写，所以dword代表4个字节。因此，一次拷贝4个字节，重复57次，那最后就一共拷贝了4×57=228个字节

也就是说，在执行完这三条指令后edi所指向的地址（0x0037fcd0）和其后面的228个地址里面所存储的内容全被赋值为CCCCCCCC，其实这里0x0037fcd0后面的第228个地址就是ebp所指向的地址。也就是说从edi所指向的地址一直到ebp所指向的地址中间这一部分全被赋值成CCCCCCCC。

值得注意的是：在执行完这三条指令后，edi所指向的地址已经发生改变，此时的edi和edp指向同一地址。

第七步：main函数中变量的创建

1：变量a的创建 接着就来到了红框圈起来的指令了，mov dword ptr [ebp-8],0Ah的意思是：把0Ah（对应十进制的10）放在edp-8（8是8个字节的意思）这个地址里面。

可见执行完这条指令后，原本ebp-8这个地址所指向空间中的CCCCCCCC被替换成了0Ah（10），说明变量a已经创建完毕。

这里也说明了一个问题，如果只是对变量进行声明而不进行初始化赋值，那内存里面存的就是CCCCCCCC（随机值，只是vs2013放的是CCCCCCCC，其他的编译器可能是其他的值），这也就是为什么我们有时打印变量会出现“烫烫烫烫”的原因

2.变量b的创建 和上面一样，这里的mov dword ptr [ebp-14h],14h指令执行的操作就是把14h（对应十进制的20）存到ebp-14h这个地址所指向的空间里。 注意，这里出现的两个14h没有任何关联，如果让b等于其他任何一个整数，始终都是把这个整数存到ebp-14h所指向的这个空间里面。

可以看出在vs2013这个编译器上，变量a和b在内存中的存储地址相差了8个字节，至于相差几个字节这以取决于编译器，不同的编译器会有不同的效果。

3：变量c的创建 和上面同理

14.3在main函数中调用Add函数

14.3.1传参

接下来就到了调用Add函数的时候了。

此时出现了两组mov和push。第一组中的mov eax,dword ptr [ebp-14h]意思是，把ebp-14h这个地址里面存放的值（也就是20）赋值给eax，然后push（压栈）eax。同理，第二组先把ebp-8这个地址里面存的值（也就是10）赋值给ecx，然后push（压栈）ecx。

经过这两次压栈后，esp指针指向的地址减小8个字节（一次减小4个字节，也就是1个整型）

14.3.2进入Add函数

在执行call指令之前，先看一下call指令下一条指令的地址，也就是add指令的地址003F1450

执行call指令时我们需要点击F11才能进入到Add函数的内部去一探究竟。

点击F11执行了call指令后，我们不但进入了Add函数的内部，还让esp指针上移了4个字节，为什么会上移呢？那一定是又元素压栈，因为只有这样才能让栈顶指针上移，那我们再来看一下压入的元素是什么呢？不难发现，压入的这个值就是call指令下一条指令add的地址003F1450。

那为什么要把call指令下一条指令的地址存起来呢？是因为在Add函数调用结束的时候，需要返回继续执行call指令的下一条指令，所以在执行call指令的时候要把call指令的下一条指令的地址存下来，在Add函数调用结束的时候，就能根据存的这个地址找到call指令的下一条指令，进而让程序继续进行。

接着再点击一次F11，就真真正正的进入到Add函数的内部了

蓝色的部分是不是特别眼熟，这部分和main函数前面那部分是一样的，就是为Add函数创建函数栈帧。

Add函数中变量z的创建
这里变量z的创建过程和main函数中变量a、b、c的创建过程一模一样，详细过程就不再进行赘述.

Add函数中的求x+y的和 接着往下，终于来到了 z = x + y，要求两数和了

求和分3条指令来完成

• 首先第一条指令mov eax,dword ptr [ebp+8]执行的结果是：把ebp+8这个地址里面存储的值放到eax里,不难发现ebp+8这个地址里面存的其实就是10（实参a和形参x的值）
• 接着第二条指令add eax,dword ptr [ebp+0Ch]的执行结果就是：把ebp+0Ch这个地址里面存储的值加到eax里面去，通过上图可以看出ebp+0Ch这个地址里面存的其实就是20（实参b和形参y的值），第二条指令执行完后eax里面存的值就变成了10和20的和，也就是30。
• 最后第三条指令mov dword ptr [ebp-8],eax执行的结果就是：把eax里面的值存到ebp-8这个地址里面（变量z的地址），也就是;z=30.

通过上面的分析可以看出，在调用Add函数的过程中，并没有创建形参x和y，而是在执行call指令调用Add函数之前就已经进行了传参，当时先让eax等于20（也就是实参b的值）先压栈，再让ecx等于10（也就是实参a的值）进行压栈，实参是按照从右到左的顺序进行传递的。当在Add函数中需要用到形参x的时候，是返回去找到ecx取出ecx里面存的值，这个值就是形参x的值。而当Add函数中需要用到形参y的时候，是返回去找到eax取出eax里面存的值，这个值就是形参y的值。 通过这里我们还可以看出，形参实际上只是实参的一份拷贝，改变形参的值不会影响实参.

14.3.3返回值return z

接下来，最重要的一步来了：就是把z=30返回到main函数里面，分成以下6条指令来完成：

• 第一条指令mov eax,dword ptr [ebp-8]的执行结果是：把ebp-8里面存的值（也就是30）存到eax里面，这里的eax是一个寄存器，它不会随着函数调用的结束而销毁掉。如果没有这条指令，在Add函数代用调用结束后的时候，ebp-8（变量z的地址）这个地址所指向的空间会被释放掉，这样的话30x+y的和就无处可寻。（上图序号1和2之间的}的右边表明Add函数调用结束）
• 接着标号2、3、4的这3条指令都执行的是pop（出栈）操作，比如pop edi的意思就是把栈顶数据弹出至edi这个寄存器里，然后栈顶指针下移，后面两个同理，

通过实际的调试也可以看出每执行一次pop指令，esp指针的值就加4这和每执行一次push指令，esp的值就减4形成呼应. 接着执行标号5的指令 mov esp,ebp，这条指令执行的结果就是把ebp存的地址给esp，也就是说，执行完这条指令后，esp和edp指向同一个地址空间。动画演示如下：

接着执行标号6的指令：pop ebp。这条指令的执行结果是：把栈顶数据弹出至edp里面进行储存。此时的栈顶数据是什么呢？通过动画不拿发现：此时的栈顶数据其实就是main函数栈底的地址呀，这样以来，执行完这条指令后edp就又指向main函数的栈底了，而此时栈顶存储的数据也变成了call指令下一条子陵的地址。动画演示如下：

最后执行ret指令**，ret指令会从栈顶弹出元素给IP，也就是下一条要执行的指令的地址**。此时的栈顶存储的就是call指令下一条指令的地址，这就是为什们当时要存call指令下一条指令的地址。是为了在Add函数调用结束后这个黄色的小箭头能够回到正确的地方继续执行接下来的指令

通过上面的调试动图可以看出：在执行完ret指令之后esp的值从个位上的8变成了个位上的c（c对应十进制下的12），二者相差4。说明确实把栈顶数据弹出了。 动画演示如下：

• 局部变量是怎么创建的？
• 为什么局部变量的值是随机值？
• 函数是怎么传参的？传参的顺序是怎么样的？
• 形参和实参是什么关系？
• 函数调用是怎么做的？
• 函数调用是结束后怎么返回的？

十五、动态内存管理

15.1为什么要有动态内存分配

我们已经掌握的内存开辟⽅式有：

int val = 20;//在栈空间上开辟四个字节
char arr[10] = {0};//在栈空间上开辟10个字节的连续空间

但是上述的开辟空间的⽅式有两个特点：

• 空间开辟⼤⼩是固定的。
• 数组在申明的时候，必须指定数组的⻓度，数组空间⼀旦确定了⼤⼩不能调整。但是对于空间的需求，不仅仅是上述的情况。有时候我们需要的空间⼤⼩在程序运⾏的时候才能知道，那数组的编译时开辟空间的⽅式就不能满⾜了。

15.2malloc和free

C语⾔引⼊了动态内存开辟，让程序员⾃⼰可以申请和释放空间，就⽐较灵活了。

15.2.1 malloc

C语⾔提供了⼀个动态内存开辟的函数：

void* malloc (size_t size);

这个函数向内存申请⼀块连续可⽤的空间，并返回指向这块空间的指针。

• 如果开辟成功，则返回⼀个指向开辟好空间的指针。
• 如果开辟失败，则返回⼀个 NULL 指针，因此malloc的返回值⼀定要做检查。
• 返回值的类型是 void* ，所以malloc函数并不知道开辟空间的类型，具体在使⽤的时候使⽤者⾃⼰来决定。如果参数 size 为0，malloc的⾏为是标准是未定义的，取决于编译器。

15.2.2 free

C语⾔提供了另外⼀个函数free，专⻔是⽤来做动态内存的释放和回收的，函数原型如下：

void free (void* ptr);

free函数⽤来释放动态开辟的内存。

• 如果参数 ptr 指向的空间不是动态开辟的，那free函数的⾏为是未定义的。
• 如果参数 ptr 是NULL指针，则函数什么事都不做。
  malloc和free都声明在 stdlib.h 头⽂件中。

举个例⼦：

#include <stdio.h>
#include <stdlib.h>
int main()
{
    int num = 0;
    scanf("%d", &num);
    int arr[num] = {0};
    int* ptr = NULL;
    ptr = (int*)malloc(num*sizeof(int));
    if(NULL != ptr)//判断ptr指针是否为空
    {
        int i = 0;
        for(i=0; i<num; i++)
        {
            *(ptr+i) = 0；
        }
    }
    free(ptr);//释放ptr所指向的动态内存
    ptr = NULL;//是否有必要？
    return 0;
}

15.3 calloc和realloc

15.3.1 calloc函数

C语⾔还提供了⼀个函数叫 calloc ， calloc 函数也⽤来动态内存分配。原型如下：

void* calloc (size_t num, size_t size);

• 函数的功能是为 num 个⼤⼩为 size 的元素开辟⼀块空间，并且把空间的每个字节初始化为0。
• 与函数 malloc 的区别只在于 calloc 会在返回地址之前把申请的空间的每个字节初始化为全0。

举个例⼦：

#include <stdio.h>
#include <stdlib.h>
int main()
{
    int *p = (int*)calloc(10, sizeof(int));
    if(NULL != p)
    {
        int i = 0;
        for(i=0; i<10; i++)
        {
            printf("%d ", *(p+i));
        }
    }
    free(p);
    p = NULL;
    return 0;
}

输出结果

0 0 0 0 0 0 0 0 0 0

所以如果我们对申请的内存空间的内容要求初始化，那么可以很⽅便的使⽤calloc函数来完成任务。

15.3.2 realloc

• realloc函数的出现让动态内存管理更加灵活。
• 有时会我们发现过去申请的空间太⼩了，有时候我们⼜会觉得申请的空间过⼤了，那为了合理的使⽤内存，我们⼀定会对内存的⼤⼩做灵活的调整。那 realloc 函数就可以做到对动态开辟内存⼤⼩的调整。

函数原型如下： 1 void* realloc (void* ptr, size_t size); • ptr 是要调整的内存地址 • size 调整之后新⼤⼩ • 返回值为调整之后的内存起始位置。 • 这个函数调整原内存空间⼤⼩的基础上，还会将原来内存中的数据移动到 新 的空间。 • realloc在调整内存空间的是存在两种情况： ◦ 情况1：原有空间之后有⾜够⼤的空间 ◦ 情况2：原有空间之后没有⾜够⼤的空间

十六、文件操作

16.1为什么使用文件？

如果没有⽂件，我们写的程序的数据是存储在电脑的内存中，如果程序退出，内存回收，数据就丢失了，等再次运⾏程序，是看不到上次程序的数据的，如果要将数据进⾏持久化的保存，我们可以使⽤⽂件。

16.2什么是⽂件？

磁盘（硬盘）上的⽂件是⽂件。
但是在程序设计中，我们⼀般谈的⽂件有两种：程序⽂件、数据⽂件（从⽂件功能的⻆度来分类的）。

十七.编译和链接

目录

1. 翻译环境和运⾏环境
2. 翻译环境：预编译+编译+汇编+链接

17.1翻译环境和运⾏环境

在ANSI C的任何⼀种实现中，存在两个不同的环境。
第1种是翻译环境，在这个环境中源代码被转换为可执⾏的机器指令（⼆进制指令）。
第2种是执⾏环境，它⽤于实际执行代码。

17.2编译环境

那翻译环境是怎么将源代码转换为可执⾏的机器指令的呢？这⾥我们就得展开开讲解⼀下翻译环境所做的事情。

其实翻译环境是由编译和链接两个⼤的过程组成的，⽽编译⼜可以分解成：预处理（有些书也叫预编译）、编译、汇编三个过程。

⼀个C语⾔的项⽬中可能有多个.c⽂件⼀起构建，那多个 .c⽂件如何⽣成可执⾏程序呢？

1. 多个.c⽂件单独经过编译器，编译处理⽣成对应的⽬标⽂件。
2. 注：在Windows环境下的⽬标⽂件的后缀是.obj，Linux环境下⽬标⽂件的后缀是.o
3. 多个⽬标⽂件和链接库⼀起经过链接器处理⽣成最终的可执⾏程序。
4. 链接库是指运⾏时库(它是⽀持程序运⾏的基本函数集合)或者第三⽅库。

如果再把编译器展开成3个过程，那就变成了下⾯的过程：

17.2.1预处理（预编译）

在预处理阶段，源⽂件和头⽂件会被处理成为.i为后缀的⽂件。 在 gcc 环境下想观察⼀下，对 test.c ⽂件预处理后的.i⽂件，命令如下：

gcc -E test.c -o test.i

预处理阶段主要处理那些源⽂件中#开始的预编译指令。⽐如：#include,#define，处理的规则如下：

• 将所有的 #define 删除，并展开所有的宏定义。
• 处理所有的条件编译指令，如： #if、#ifdef、#elif、#else、#endif 。
• 处理#include 预编译指令，将包含的头⽂件的内容插⼊到该预编译指令的位置。这个过程是递归进⾏的，也就是说被包含的头⽂件也可能包含其他⽂件。
• 删除所有的注释
• 添加⾏号和⽂件名标识，⽅便后续编译器⽣成调试信息等。
• 或保留所有的#pragma的编译器指令，编译器后续会使⽤。 经过预处理后的.i⽂件中不再包含宏定义，因为宏已经被展开。并且包含的头⽂件都被插⼊到.i⽂件中。所以当我们⽆法知道宏定义或者头⽂件是否包含正确的时候，可以查看预处理后的.i⽂件来确认。

17.2.2编译

编译过程就是将预处理后的⽂件进⾏⼀系列的：词法分析、语法分析、语义分析及优化，⽣成相应的汇编代码⽂件。

编译过程的命令如下：

gcc -S test.i -o 

17.2.2.1词法分析

将源代码程序被输⼊扫描器，扫描器的任务就是简单的进⾏词法分析，把代码中的字符分割成⼀系列的记号（关键字、标识符、字⾯量、特殊字符等）。

17.2.2.2语法分析

接下来语法分析器，将对扫描产⽣的记号进⾏语法分析，从⽽产⽣语法树。这些语法树是以表达式为节点的树。

17.2.2.3语义分析

由语义分析器来完成语义分析，即对表达式的语法层⾯分析。编译器所能做的分析是语义的静态分析。静态语义分析通常包括声明和类型的匹配，类型的转换等。这个阶段会报告错误的语法信息。

17.2.3汇编

汇编器是将汇编代码转转变成机器可执⾏的指令，每⼀个汇编语句⼏乎都对应⼀条机器指令。就是根据汇编指令和机器指令的对照表⼀⼀的进⾏翻译，也不做指令优化。
汇编的命令如下：

gcc -c test.s -o test.o

17.2.4链接

链接是⼀个复杂的过程，链接的时候需要把⼀堆⽂件链接在⼀起才⽣成可执⾏程序。
链接过程主要包括：地址和空间分配，符号决议和重定位等这些步骤。 链接解决的是⼀个项⽬中多⽂件、多模块之间互相调⽤的问题。

比如：
在⼀个C的项⽬中有2个.c⽂件（ test.c 和 add.c ），代码如下：

test.c

#include <stdio.h>
//test.c
//声明外部函数
extern int Add(int x, int y);
//声明外部的全局变量
extern int g_val;
int main()
{
    int a = 10;
    int b = 20;
    int sum = Add(a, b);
    printf("%d\n", sum);
    return 0;
}

add.c

int g_val = 2022;
int Add(int x, int y)
{
    return x+y;
}

我们已经知道，每个源⽂件都是单独经过编译器处理⽣成对应的⽬标⽂件。
test.c 经过编译器处理⽣成test.o
add.c 经过编译器处理⽣成add.o

我们在 test.c 的⽂件中使⽤了 add.c ⽂件中的 Add 函数和 g_val 变量。

我们在 test.c ⽂件中每⼀次使⽤ Add 函数和 g_val 的时候必须确切的知道 Add 和 g_val 的地址，但是由于每个⽂件是单独编译的，在编译器编译 test.c 的时候并不知道 Add 函数和 g_val 变量的地址，所以暂时把调⽤ Add 的指令的⽬标地址和 g_val 的地址搁置。等待最后链接的时候由链接器根据引⽤的符号 Add 在其他模块中查找 Add 函数的地址，然后将 test.c 中所有引⽤到 Add 的指令重新修正，让他们的⽬标地址为真正的 Add 函数的地址，对于全局变量 g_val 也是类似的⽅法来修正地址。这个地址修正的过程也被叫做：重定位

前⾯我们⾮常简洁的讲解了⼀个C的程序是如何编译和链接，到最终⽣成可执⾏程序的过程，其实很多内部的细节⽆法展开讲解。⽐如：⽬标⽂件的格式elf，链接底层实现中的空间与地址分配，符号解析和重定位等，如果你有兴趣，可以看《程序的⾃我修养》⼀书来详细了解。

17.3运⾏环境

1. 程序必须载⼊内存中。在有操作系统的环境中：⼀般这个由操作系统完成。在独⽴的环境中，程序的载⼊必须由⼿⼯安排，也可能是通过可执⾏代码置⼊只读内存来完成。
2. 程序的执⾏便开始。接着便调⽤main函数。
3. 开始执⾏程序代码。这个时候程序将使⽤⼀个运⾏时堆栈（stack），存储函数的局部变量和返回地址。程序同时也可以使⽤静态（static）内存，存储于静态内存中的变量在程序的整个执⾏过程⼀直保留他们的值。
4. 终⽌程序。正常终⽌main函数；也有可能是意外终⽌。

十八.预处理详解

目录

1. 预定义符号
2. #define定义常量
3. #define定义宏
4. 带有副作⽤的宏参数
5. 宏替换的规则
6. 宏函数的对⽐
7. #和##
8. 命名约定
9. #undef
10. 命令⾏定义
11. 条件编译
12. 头⽂件的包含
13. 其他预处理指令

18.1. 预定义符号

C语⾔设置了⼀些预定义符号，可以直接使⽤，预定义符号也是在预处理期间处理的。

__FILE__ //进⾏编译的源⽂件
__LINE__ //⽂件当前的⾏号
__DATE__ //⽂件被编译的⽇期
__TIME__ //⽂件被编译的时间
__STDC__ //如果编译器遵循ANSI C，其值为1，否则未定义

举个例⼦：

printf("file:%s line:%d\n", __FILE__, __LINE__);

18.2#define 定义常量

基本语法:

#define name stuff

举个例⼦：

#define MAX 1000
#define reg register //为 register这个关键字，创建⼀个简短的名字
#define do_forever for(;;) //⽤更形象的符号来替换⼀种实现
#define CASE break;case //在写case语句的时候⾃动把 break写上。
// 如果定义的 stuff过⻓，可以分成⼏⾏写，除了最后⼀⾏外，每⾏的后⾯都加⼀个反斜杠(续⾏符)。
#define DEBUG_PRINT printf("file:%s\tline:%d\t \
 date:%s\ttime:%s\n" ,\
 __FILE__,__LINE__ , \
 __DATE__,__TIME__ ) 

思考：在define定义标识符的时候，要不要在最后加上 ; ? ⽐如：

#define MAX 1000;
#define MAX 1000

建议不要加上 ; ,这样容易导致问题。 ⽐如下⾯的场景：

if(condition)
    max = MAX;
else
    max = 0;

如果是加了分号的情况，等替换后，if和else之间就是2条语句，⽽没有⼤括号的时候，if后边只能有⼀条语句。这⾥会出现语法错误。

18.3#define定义宏

#define 机制包括了⼀个规定，允许把参数替换到⽂本中，这种实现通常称为宏（macro）或定义宏（define macro）。
下⾯是宏的申明⽅式：

#define name( parament-list ) stuff

其中的 parament-list 是⼀个由逗号隔开的符号表，它们可能出现在stuff中。 注意：

参数列表的左括号必须与name紧邻，如果两者之间有任何空⽩存在，参数列表就会被解释为stuff的⼀部分。

举例：

#define SQUARE( x ) x * x

这个宏接收⼀个参数 x .如果在上述声明之后，你把 SQUARE( 5 ); 置于程序中，预处理器就会⽤下⾯这个表达式替换上⾯的表达式：5 * 5 警告：
这个宏存在⼀个问题：
观察下⾯的代码段：

int a = 5;
printf("%d\n" ,SQUARE( a + 1) );

乍⼀看，你可能觉得这段代码将打印36，事实上它将打印11，为什么呢？
替换⽂本时，参数x被替换成a + 1,所以这条语句实际上变成了：

printf ("%d\n",a + 1 * a + 1 );

这样就⽐较清晰了，由替换产⽣的表达式并没有按照预想的次序进⾏求值。在宏定义上加上两个括号，这个问题便轻松的解决了：

#define SQUARE(x) (x) * (x)

这样预处理之后就产⽣了预期的效果：

printf ("%d\n",(a + 1) * (a + 1) );

这⾥还有⼀个宏定义：

#define DOUBLE(x) (x) + (x)

定义中我们使⽤了括号，想避免之前的问题，但是这个宏可能会出现新的错误。

int a = 5;
printf("%d\n" ,10 * DOUBLE(a));

这将打印什么值呢？看上去，好像打印100，但事实上打印的是55. 我们发现替换之后：

printf ("%d\n",10 * (5) + (5));

乘法运算先于宏定义的加法，所以出现了 55 . 这个问题，的解决办法是在宏定义表达式两边加上⼀对括号就可以了。

#define DOUBLE( x) ( ( x ) + ( x ) )

提⽰：

所以⽤于对数值表达式进⾏求值的宏定义都应该⽤这种⽅式加上括号，避免在使⽤宏时由于参数中的操作符或邻近操作符之间不可预料的相互作⽤。

18.4带有副作⽤的宏参数

当宏参数在宏的定义中出现超过⼀次的时候，如果参数带有副作⽤，那么你在使⽤这个宏的时候就可能出现危险，导致不可预测的后果。副作⽤就是表达式求值的时候出现的永久性效果。 例如：

x+1;//不带副作⽤
x++;//带有副作⽤

MAX宏可以证明具有副作⽤的参数所引起的问题。

#define MAX(a, b) ( (a) > (b) ? (a) : (b) )
...
x = 5;
y = 8;
z = MAX(x++, y++);
printf("x=%d y=%d z=%d\n", x, y, z);//输出的结果是什么？

这⾥我们得知道预处理器处理之后的结果是什么：

z = ( (x++) > (y++) ? (x++) : (y++));

所以输出的结果是：x=6 y=10 z=9

18.5宏替换的规则

在程序中扩展#define定义符号和宏时，需要涉及⼏个步骤。

1. 在调⽤宏时，⾸先对参数进⾏检查，看看是否包含任何由#define定义的符号。如果是，它们⾸先被替换。
2. 替换⽂本随后被插⼊到程序中原来⽂本的位置。对于宏，参数名被他们的值所替换。
3. 最后，再次对结果⽂件进⾏扫描，看看它是否包含任何由#define定义的符号。如果是，就重复上述处理过程。

注意：

1. 宏参数和#define 定义中可以出现其他#define定义的符号。但是对于宏，不能出现递归。
2. 当预处理器搜索#define定义的符号的时候，字符串常量的内容并不被搜索。

18.6宏函数的对比

宏通常被应⽤于执⾏简单的运算。
⽐如在两个数中找出较⼤的⼀个时，写成下⾯的宏，更有优势⼀些。

#define MAX(a, b) ((a)>(b)?(a):(b))

那为什么不⽤函数来完成这个任务？

原因有⼆：

1. ⽤于调⽤函数和从函数返回的代码可能⽐实际执⾏这个⼩型计算⼯作所需要的时间更多。所以宏⽐函数在程序的规模和速度⽅⾯更胜⼀筹。
2. 更为重要的是函数的参数必须声明为特定的类型。所以函数只能在类型合适的表达式上使⽤。反之这个宏怎可以适⽤于整形、⻓整型、浮点型等可以⽤于 > 来⽐较的类型。宏的参数是类型⽆关的。

和函数相⽐宏的劣势：

1. 每次使⽤宏的时候，⼀份宏定义的代码将插⼊到程序中。除⾮宏⽐较短，否则可能⼤幅度增加程序的⻓度。
2. 宏是没法调试的。
3. 宏由于类型⽆关，也就不够严谨。
4. 宏可能会带来运算符优先级的问题，导致程容易出现错。

宏有时候可以做函数做不到的事情。⽐如：宏的参数可以出现类型，但是函数做不到。

#define MALLOC(num, type)
 (type )malloc(num sizeof(type))
 ...
//使⽤
 MALLOC(10, int);//类型作为参数
//预处理器替换之后：
 (int *)malloc(10 sizeof(int));

18.7#和##

18.7.1#运算符

#运算符将宏的⼀个参数转换为字符串字⾯量。它仅允许出现在带参数的宏的替换列表中。#运算符所执⾏的操作可以理解为”字符串化“。 当我们有⼀个变量int a = 10; 的时候，我们想打印出:the value of a is 10. 就可以写：

#define PRINT(n) printf("the value of "#n " is %d", n);

当我们按照下⾯的⽅式调⽤的时候：
PRINT(a);//当我们把a替换到宏的体内时，就出现了#a，⽽#a就是转换为"a"，时⼀个字符串代码就会被预处理为：

printf("the value of ""a" " is %d", a);

运⾏代码就能在屏幕上打印：

the value of a is 10

18.7.2 ##运算符

## 可以把位于它两边的符号合成⼀个符号，它允许宏定义从分离的⽂本⽚段创建标识符. ## 被称为记号粘合. 这样的连接必须产⽣⼀个合法的标识符。否则其结果就是未定义的。 这⾥我们想想，写⼀个函数求2个数的较⼤值的时候，不同的数据类型就得写不同的函数。

⽐如：

int int_max(int x, int y)
{
    return x>y?x:y;    
}
float float_max(float x, float y)
{
    return x>y?x:y;    
}

但是这样写起来太繁琐了，现在我们这样写代码试试：

//宏定义
#define GENERIC_MAX(type) 
type type##_max(type x, type y)
{ 
    return (x>y?x:y);     
}

使⽤宏，定义不同函数:

GENERIC_MAX(int) //替换到宏体内后int##_max ⽣成了新的符号 int_max做函数名
GENERIC_MAX(float) //替换到宏体内后float##_max ⽣成了新的符号 float_max做函数名
int main()
{
    //调⽤函数
    int m = int_max(2, 3);
    printf("%d\n", m);
    float fm = float_max(3.5f, 4.5f);
    printf("%f\n", fm);
    return 0;
}

输出：

3
4.500000

在实际开发过程中##使⽤的很少，很难取出⾮常贴切的例⼦。

18.8命名约定

⼀般来讲函数的宏的使⽤语法很相似。所以语⾔本⾝没法帮我们区分⼆者。
那我们平时的⼀个习惯是：

把宏名全部⼤写
函数名不要全部⼤写

18.9#undef

这条指令⽤于移除⼀个宏定义。

#undef NAME
//如果现存的⼀个名字需要被重新定义，那么它的旧名字⾸先要被移除。

18.10命令行定义

许多C 的编译器提供了⼀种能⼒，允许在命令⾏中定义符号。⽤于启动编译过程。
例如：当我们根据同⼀个源⽂件要编译出⼀个程序的不同版本的时候，这个特性有点⽤处。（假定某个程序中声明了⼀个某个⻓度的数组，如果机器内存有限，我们需要⼀个很⼩的数组，但是另外⼀个 机器内存⼤些，我们需要⼀个数组能够⼤些。）

#include <stdio.h>
int main()
{
    int array [ARRAY_SIZE];
    int i = 0;
    for(i = 0; i< ARRAY_SIZE; i ++)
    {
        array[i] = i;
    }
    for(i = 0; i< ARRAY_SIZE; i ++)
    {
        printf("%d " ,array[i]);
    }
    printf("\n" );
    return 0;
}

编译指令：

//linux 环境演⽰
gcc -D ARRAY_SIZE=10 programe.c

18.11条件编译

在编译⼀个程序的时候我们如果要将⼀条语句（⼀组语句）编译或者放弃是很⽅便的。因为我们有条件编译指令。
⽐如说：
调试性的代码，删除可惜，保留⼜碍事，所以我们可以选择性的编译。

#include <stdio.h>
#define __DEBUG__
int main()
{
    int i = 0;
    int arr[10] = {0};
    for(i=0; i<10; i++)
    {
        arr[i] = i;
        #ifdef __DEBUG__
            printf("%d\n", arr[i]);//为了观察数组是否赋值成功。 
        #endif //__DEBUG__
    }
    return 0;
}

常见的条件编译指令：

1.
#if 常量表达式
 //...
#endif
//常量表达式由预处理器求值。
如：
#define __DEBUG__ 1
#if __DEBUG__
 //..
#endif

2.多个分⽀的条件编译
#if 常量表达式
 //...
#elif 常量表达式
 //...
#else
 //...
#endif

3.判断是否被定义
#if defined(symbol)
#ifdef symbol
#if !defined(symbol)
#ifndef symbol

4.嵌套指令
#if defined(OS_UNIX)
    #ifdef OPTION1
        unix_version_option1();
    #endif
    #ifdef OPTION2
        unix_version_option2();
    #endif
#elif defined(OS_MSDOS)
        #ifdef OPTION2
        msdos_version_option2();
        #endif
#endif

18.12头⽂件的包含

18.12.1 头⽂件被包含的⽅式：

• 本地包含
• 库文件包含

18.12.1.1 本地⽂件包含

#include "filename"

查找策略：先在源⽂件所在⽬录下查找，如果该头⽂件未找到，编译器就像查找库函数头⽂件⼀样在标准位置查找头⽂件。 如果找不到就提⽰编译错误。

• Linux环境的标准头⽂件的路径：

/usr/include

• VS环境的标准头⽂件的路径：

C:\Program Files (x86)\Microsoft Visual Studio 12.0\VC\include
//这是VS2013的默认路径

18.12.1.2库⽂件包含

#include <filename.h>

查找头⽂件直接去标准路径下去查找，如果找不到就提⽰编译错误。 这样是不是可以说，对于库⽂件也可以使⽤ “” 的形式包含？ 答案是肯定的，可以，但是这样做查找的效率就低些，当然这样也不容易区分是库⽂件还是本地⽂件了。

18.12.2嵌套⽂件包含

我们已经知道， #include 指令可以使另外⼀个⽂件被编译。就像它实际出现于 #include 指令的地⽅⼀样。
这种替换的⽅式很简单：预处理器先删除这条指令，并⽤包含⽂件的内容替换。
⼀个头⽂件被包含10次，那就实际被编译10次，如果重复包含，对编译的压⼒就⽐较⼤。

test.c

#include "test.h"
#include "test.h"
#include "test.h"
#include "test.h"
#include "test.h"
int main()
{
 
 return 0;
}

test.h

void test();
struct Stu
{
    int id;
    char name[20];
};

如果直接这样写，test.c⽂件中将test.h包含5次，那么test.h⽂件的内容将会被拷⻉5份在test.c中。
如果test.h ⽂件⽐较⼤，这样预处理后代码量会剧增。如果⼯程⽐较⼤，有公共使⽤的头⽂件，被⼤家都能使⽤，⼜不做任何的处理，那么后果真的不堪设想。
如何解决头⽂件被重复引⼊的问题？答案：条件编译。
每个头⽂件的开头写：

#ifndef __TEST_H__
#define __TEST_H__
//头⽂件的内容
#endif //__TEST_H__

或者

#pragma once

就可以避免头⽂件的重复引⼊。 注： 推荐《⾼质量C/C++编程指南》中附录的考试试卷（很重要）。 笔试题：

1. 头⽂件中的 ifndef/define/endif是⼲什么⽤的?
2. #include <filename.h> 和 #include "filename.h" 有什么区别?

18.13其他预处理指令

#error
#pragma
#line
...
不做介绍，⾃⼰去了解。
#pragma pack()在结构体部分介绍。

C语言常见库函数整理

为了支持可移植性和提高程序的效率，所以C语言的基础库中提供了一系列类似的库函数,方便程序员开发软件。

简单的总结，C语言常用的库函数都有:

• IO函数 <stdio.h>
• 字符串操作函数
• 字符操作函数
• 内存操作函数
• 时间/日期函数
• 数学函数
• 其他库函数

一、IO函数

目录：

1. printf()
2. scanf()
3. getchar()和putchar()

(1)printf()的使用方法

注意：

1. 它名字里面的f代表format（格式化），表示可以定制输出文本的格式。
2. printf()不会在行尾自动添加换行符，运行结束后，光标就停留在输出结束的地方，不会自动换行。
3. printf()可以在输出文本中指定占位符,“占位符”，就是这个位置可以用其他值代入。

*\n换行符

为了让光标移到下⼀⾏的开头，可以在输出⽂本的结尾，添加⼀个换⾏符 \n 。

#include <stdio.h>
int main(void) 
{
   printf("Hello World\n");
   return 0;
}

如果⽂本内部有换⾏，也是通过插⼊换⾏符来实现，如下⽅代码：

#include <stdio.h>
int main(void) 
{
   printf("Hello\nWorld\n");
 
   printf("Hello\n");
   printf("World\n");
   return 0;
}

1.printf()的占位符

printf() 的占位符有许多种类，与 C 语⾔的数据类型相对应。下⾯按照字⺟顺序，列出常⽤的占位符，⽅便查找，具体含义在后⾯章节介绍。

• %a ：⼗六进制浮点数，字⺟输出为⼩写。
• %A ：⼗六进制浮点数，字⺟输出为⼤写。
• %c ：字符。
• %d ：⼗进制整数。
• %e ：使⽤科学计数法的浮点数，指数部分的 e 为⼩写。
• %E ：使⽤科学计数法的浮点数，指数部分的 E 为⼤写。
• %i ：整数，基本等同于 %d 。
• %f ：⼩数（包含 float 类型和 double 类型）。
• %g ：6个有效数字的浮点数。整数部分⼀旦超过6位，就会⾃动转为科学计数法，指数部分的 e 为⼩写。
• %G ：等同于 %g ，唯⼀的区别是指数部分的 E 为⼤写。
• %hd ：⼗进制 short int 类型。
• %ho ：⼋进制 short int 类型。
• %hx ：⼗六进制 short int 类型。
• %hu ：unsigned short int 类型。
• %ld ：⼗进制 long int 类型。
• %lo ：⼋进制 long int 类型。
• %lx ：⼗六进制 long int 类型。
• %lu ：unsigned long int 类型。
• %lld ：⼗进制 long long int 类型。
• %llo ：⼋进制 long long int 类型。
• %llx ：⼗六进制 long long int 类型。
• %llu ：unsigned long long int 类型。
• %Le ：科学计数法表⽰的 long double 类型浮点数。
• %Lf ：long double 类型浮点数。
• %n ：已输出的字符串数量。该占位符本⾝不输出，只将值存储在指定变量之中。
• %o ：⼋进制整数。
• %p ：指针。
• %s ：字符串。
• %u ：⽆符号整数（unsigned int）。
• %x ：⼗六进制整数。
• %zd ： size_t 类型。
• %% ：输出⼀个百分号。

这⾥的 %d , %c 等是占位符，会被后边的值替换。

• %d--打印整型
  可以在""内添加注释,
  %02d表示补齐到两位,"0"表示补齐的内容,但是只能是"0". 如果超过2位，那么就会正常输出。

printf("year=%d\n",year);
printf("year=%02d\n",year);

• %c--打印字符
  'w' (单个字符采用c,多个字符就是字符串了) ;如果后面跟的是ascll码值，那么会直接打印ascll对应字符。

printf("%c\n",'w');
printf("%c\n",97);

• %s--打印字符串 两种方法

printf("abcdef\n");//只有字符串可以这样
printf("%s\n","abcdef");  
printf("%s will come tonight\n", "zhangsan");

一个引号引起来的是字符，两个引号引起来的是字符串。

• %f--打印浮点数float
  • 如果f前面啥也不加,那么默认6位小数,大于等于6位的部分会被舍掉,最后一位会根据第六位四舍五入的结果显示,但无论如何影响不了倒数第二位;
  • 小于6位的会在后面用0去补全.
  • 在f的前面添加.2表示保留两位小数,同样最后一位会根据它后面的那一位四舍五入;如果本来给的浮点数没有达到要保留的位数,则会在后面添0.

printf("%f\n",58.8888888);
printf("%.2f",58.88888);

结果：
58.888889
58.89

• %lf--打印double类型的数据
• %zu--打印sizeof的返回值
• %p--打印地址

printf("%p\n",&a);

直接转义某个字符

printf() 参数与占位符是⼀⼀对应关系，如果有 n 个占位符,printf() 的参数就应该有 n + 1 个。如果参数个数少于对应的占位符， printf() 可能会输出内存中的任意值。

*辨析c语言中%d,%%d,%%%d和\\%d的区别

1. %d，表示按整型输出后面给出的变量的值。

2. %%d ，这就会被拆成两部分看待，一是“%%”在C语言中就是输出一个“%”，而是“d”就是一个普通字符，所以当“%%d”在一起时，其含义就是输出“%d”这两个字符。

3. %%%d ，3个%在一起，进行拆分的话，%%代表一个“%”字符，后面的%d又代表整型输出变量的值，所以当“%%%d”一起时，其最终含义就是输出一个字符%号再接着按整型输出变量的值。类似的\符号也是一样。

C语言中，%是转义符，也就是和%一起出现的后面的内容会转义后输出

2.printf()输出格式

可以定制占位符的输出格式。

• printf() 允许限定占位符的最小宽度。

#include <stdio.h>
int main()
{
   printf("%5d\n", 123); // 输出为 " 123"
   return 0;
}

上⾯⽰例中， %5d 表⽰这个占位符的宽度⾄少为5位。如果不满5位，对应的值的前⾯会添加空格。输出的值默认是右对⻬，即输出内容前⾯会有空格；如果希望改成左对⻬，在输出内容后⾯添加空格，可以在占位符的 % 的后⾯插⼊⼀个-号。

#include <stdio.h>
int main()
{
   printf("%-5d\n", 123); // 输出为 "123 "
   return 0;
}

对于⼩数，这个限定符会限制所有数字的最⼩显⽰宽度。

// 输出 " 123.450000",前面有两个空格
#include <stdio.h>
int main()
{
   printf("%12f\n", 123.45);
   return 0;
}

上⾯⽰例中， %12f 表⽰输出的浮点数最少要占据12位。由于⼩数的默认显⽰精度是⼩数点后6位，所以 123.45 输出结果的头部会添加2个空格。

• 总是显示+-号 默认情况下， printf() 不对正数显⽰ + 号，只对负数显⽰ - 号。如果想让正数也输出 + 号，可以在占位符的 % 后⾯加⼀个 + 。

#include <stdio.h>
int main()
{
   printf("%+d\n", 12); // 输出 +12
   printf("%+d\n", -12); // 输出 -12
   return 0;
}

• 限定⼩数位数 输出⼩数时，有时希望限定⼩数的位数。举例来说，希望⼩数点后⾯只保留两位，占位符可以写成 %.2f 。

// 输出 Number is 0.50
#include <stdio.h>
int main()
{
   printf("Number is %.2f\n", 0.5);
   return 0;
}

上⾯⽰例中，如果希望⼩数点后⾯输出3位（ 0.500 ），占位符就要写成 %.3f 。

这种写法可以与限定宽度占位符，结合使⽤。

// 输出为 " 0.50",前面有俩空格
#include <stdio.h>
int main()
{
   printf("%6.2f\n", 0.5);
   return 0;
}

上⾯⽰例中， %6.2f 表⽰输出字符串最⼩宽度为6，⼩数位数为2。所以，输出字符串的头部有两个空格。

• 用*代替传址 最⼩宽度和⼩数位数这两个限定值，都可以⽤ * 代替，通过 printf() 的参数传⼊。

#include <stdio.h>
int main()
{
   printf("%*.*f\n", 6, 2, 0.5);
   return 0;
}
// 等同于printf("%6.2f\n", 0.5);

上⾯⽰例中， %*.*f 的两个星号通过 printf() 的两个参数 6 和 2 传⼊。

• 输出部分字符串 %s 占位符⽤来输出字符串，默认是全部输出。如果只想输出开头的部分，可以⽤ %.[m]s 指定输出的⻓度，其中 [m] 代表⼀个数字，表⽰所要输出的⻓度。

// 输出 hello
#include <stdio.h>
int main()
{
   printf("%.5s\n", "hello world");
   return 0;
}

上⾯⽰例中，占位符 %.5s 表⽰只输出字符串“hello world”的前5个字符，即“hello”。

3.printf的返回值

printf函数是有返回值的,返回的是输出的字符串的长度

int main()
{
    int a = printf("hehe");
    //不能在这个之后直接加上\n,原因是返回值会把\n也算进去,返回值就多了1
    printf("\n%d\n",a);//注意\n也可以写在前面
    return 0;
}

(2)scanf()的使用方法

scanf的功能：用一句话来概括就是“通过键盘给程序中的变量赋值”。 程序运⾏到这个语句时，会停下来，等待⽤⼾从键盘输⼊。 ⽤⼾输⼊数据、按下回⻋键后， scanf() 就会处理⽤⼾的输⼊，将其存⼊变量。它的原型定义在头⽂件stdio.h。

函数的原型

int scanf(const char *format, ...);

1.基本用法

作用：将从键盘输入的字符转化为输入控制符所规定格式的数据，然后存入已输入参数的值为地址的变量中。

scanf("%d", &i)

1. %d 键盘上输入的是字符，必须使用%d，把输入的字符转换为十进制整数。
2. &i 取地址运算符&，把输入的字符经转化为整数后存到&i这个地址对应的变量i中。(变量i需要提前创建)。
3. 注意：变量前⾯必须加上 & 运算符（指针变量除外），因为 scanf() 传递的不是值，⽽是地址，即将变量 i 的地址指向⽤⼾输⼊的值。 如果这⾥的变量是指针变量（⽐如字符串变量），那就不⽤加 & 运算符。

注意：变量前⾯必须加上 & 运算符（指针变量除外），因为 scanf() 传递的不是值，⽽是地址，即将变量 i 的地址指向⽤⼾输⼊的值。 如果这⾥的变量是指针变量（⽐如字符串变量），那就不⽤加 & 运算符。

scanf() 处理数值占位符时，会⾃动过滤空⽩字符，包括空格、制表符、换⾏符等。

所以，⽤⼾输⼊的数据之间，有⼀个或多个空格不影响 scanf() 解读数据。另外，⽤⼾使⽤回⻋键，将输⼊分成⼏⾏，也不影响解读。

1
-20
3.4
-4.0e3

上⾯⽰例中，⽤⼾分成四⾏输⼊，得到的结果与⼀⾏输⼊是完全⼀样的。每次按下回⻋键以后，scanf() 就会开始解读，如果第⼀⾏匹配第⼀个占位符，那么下次按下回⻋键时，就会从第⼆个占位符开始解读。

scanf() 处理⽤⼾输⼊的原理是，⽤⼾的输⼊先放⼊缓存，等到按下回⻋键后，按照占位符对缓存进⾏解读。解读⽤⼾输⼊时，会从上⼀次解读遗留的第⼀个字符开始，直到读完缓存，或者遇到第⼀个不符合条件的字符为⽌。

#include <stdio.h>
int main()
{
   int x;
   float y;
 
   // ⽤⼾输⼊ " -13.45e12# 0"
   scanf("%d", &x);
   printf("%d\n", x);
   scanf("%f", &y);
   printf("%f\n", y);
   return 0;
}

上⾯⽰例中， scanf() 读取⽤⼾输⼊时， %d 占位符会忽略起⾸的空格，从 - 处开始获取数据，读取到 -13 停下来，因为后⾯的 . 不属于整数的有效字符。这就是说，占位符 %d 会读到 -13 。 第⼆次调⽤ scanf() 时，就会从上⼀次停⽌解读的地⽅，继续往下读取。这⼀次读取的⾸字符是.，由于对应的占位符是 %f ，会读取到 .45e12 ，这是采⽤科学计数法的浮点数格式。后⾯的#不属于浮点数的有效字符，所以会停在这⾥。

由于 scanf() 可以连续处理多个占位符，所以上⾯的例⼦也可以写成下⾯这样。

#include <stdio.h>
int main()
{
   int x;
   float y;
 
   // ⽤⼾输⼊ " -13.45e12# 0"
   scanf("%d%f", &x, &y);
   return 0;
}

2.scanf的返回值

scanf() 的返回值是⼀个整数，表⽰成功读取的变量个数。
如果没有读取任何项，或者匹配失败，则返回 0 。如果在成功读取任何数据之前，发⽣了读取错误或者遇到读取到⽂件结尾，则返回常量EOF。

#include <stdio.h>
int main()
{
   int a = 0;
   int b = 0;
   float f = 0.0f;
   int r = scanf("%d %d %f", &a, &b, &f);
   printf("a=%d b=%d f=%f\n", a, b, f);
   printf("r = %d\n", r);
   return 0;
}

如果⼀个数字都不输⼊，直接按3次 ctrl+z退出 ,输出的r是-1，也就是EOF。

3.占位符

scanf()常⽤的占位符如下,与 printf()的占位符基本⼀致。

• %c:字符。
• %d:整数。
• %f:float类型浮点数。
• %lf:double类型浮点数。
• %Lf:long double类型浮点数。(大写L)
• %s：字符串。
• %[]：在⽅括号中指定⼀组匹配的字符（⽐如 %[0-9]），遇到不在集合之中的字符，匹配将会停⽌。

上⾯所有占位符之中，除了%c以外，都会⾃动忽略起⾸的空⽩字符。

%c 不忽略空⽩字符,总是返回当前第⼀个字符，⽆论该字符是否为空格。如果要强制跳过字符前的空⽩字符，可以写成 scanf(" %c", &ch) ，即 %c 前加上⼀个空格，表⽰跳过零个或多个空⽩字符。

下⾯要特别说⼀下占位符%s，它其实不能简单地等同于字符串。它的规则是，从当前第⼀个⾮空⽩字符开始读起，直到遇到空⽩字符（即空格、换⾏符、制表符等）为⽌。

因为 %s 不会包含空⽩字符，所以⽆法⽤来读取多个单词，除⾮多个 %s ⼀起使⽤。这也意味着，scanf() 不适合读取可能包含空格的字符串，⽐如书名或歌曲名。另外， scanf() 遇到 %s 占位符，会在字符串变量末尾存储⼀个空字符 \0。

scanf() 将字符串读⼊字符数组时，不会检测字符串是否超过了数组⻓度。所以，储存字符串时，很可能会超过数组的边界，导致预想不到的结果。为了防⽌这种情况，使⽤ %s 占位符时，应该指定 读⼊字符串的最⻓⻓度，即写成 %[m]s ，其中的 [m] 是⼀个整数，表⽰读取字符串的最⼤⻓度，后⾯的字符将被丢弃。

#include <stdio.h>
int main()
{
   char name[11];
   scanf("%10s", name);
   return 0;
}

上⾯⽰例中， name 是⼀个⻓度为11的字符数组， scanf() 的占位符 %10s 表⽰最多读取⽤⼾输⼊的10个字符，后⾯的字符将被丢弃，这样就不会有数组溢出的⻛险了。

以下代码的目的是从一串包含生日信息的数字中输出,输出年,月,日的信息.

#include <stdio.h>
int main()
{
    int year = 0;
    int month = 0;
    int day =0;
    scanf("%4d%2d%2d", &year, &month, &day);
    //这里的4d,2d,2d是指指定的扫描宽度,从前往后,超过的的部分将不会被扫描
    //这里的%4d%2d%2d与输入的与那一串数字格式是一样的
    printf("year=%d\n",year);
    printf("month=%02d\n",month);
    //02d的意思是,指定输出的宽度为2,宽度不足2的前面拿0来补足,d指的是整型,另外,如果只是2d,没有0,如果宽度不够,那么他会输出 空格＋数字
    printf("day=%02d\n",day);
}

以下代码的目的是指定格式的信息中提取再输出 其中学号和成绩用;隔开,成绩和成绩之间使用,隔开.

int main()
{
    int id = 0;
    float c = 0.0f;//float类型创建的变量默认是double,在后面加上f则会强制锁定float类型
    float math = 0.0f;
    float english = 0.0f;
    scanf("%d;%f,%f,%f", &id, &c, &math, &english);
    //这里的%d;%f,%f,%f与输入的与那一串数字格式是一样的
    printf("The each subject score of NO. %d is %.2f, %.2f, %.2f", id, c, math, english);
}

例子:

#include<stdio.h>
int main()
{
    int a,b;
    printf("请输入整数：");
    scanf("%d",&a);// %d,将输入的字符转化为十进制形式
    printf("a=%d\n",a);// %d,以十进制输出a的值，\n换行符
    b=a>0?1:-1;//三目运算符，当a>0,b=1;否则b=-1
    printf("b=%d\n",b);
    return 0;
}

4.原样输入原则

作用：将从键盘输入的字符转化为输入控制符所规定格式的数据，然后存入已输入参数的值为地址的变量中（非输入控制符必须原样输入）。

例子:

#include<stdio.h>
int main()
{
    int a,b;
    printf("请输入整数：");
    scanf("a=%d",&a);//   %d,将输入的字符转化为十进制形式
    //这里不一样
    b=a>0?1:-1;//三目运算符，当a>0,b=1;否则b=-1
    printf("b=%d\n",b);
    return 0;
}

根据scanf("a=%d",&a)双引号里的内容”a=%d"，在终端输入必须输入“a=数字",然后回车，注意"a="不能少，否则程序不能向下执行。

极端一点的例子：

scanf("%d, %daaa", &a, &b);

输入时必须输入"6,8aaa"格式才可以，空格倒无所谓

总结：推荐第一种用法，尽量不要用非输入控制符，可以结合printf使用来提示输入的东西，然后根据提示直接输入就好。

5.赋值忽略符

有时，⽤⼾的输⼊可能不符

#include <stdio.h>
int main()
{
   int year = 0;
   int month = 0;
   int day = 0;
   scanf("%d-%d-%d", &year, &month, &day);
   printf("%d %d %d\n", year, month, day);
   return 0;
}

上⾯⽰例中，如果⽤⼾输⼊ 2020-01-01 ，就会正确解读出年、⽉、⽇。问题是⽤⼾可能输⼊其他格式，⽐如 2020/01/01 ，这种情况下， scanf() 解析数据就会失败。为了避免这种情况， scanf() 提供了⼀个赋值忽略符（assignment suppression character） * 。 只要把 * 加在任何占位符的百分号后⾯，该占位符就不会返回值，解析后将被丢弃。

#include <stdio.h>
int main()
{
   int year = 0;
   int month = 0;
   int day = 0;
   scanf("%d%*c%d%*c%d", &year, &month, &day);
   return 0;
}

上⾯⽰例中，%*c 就是在占位符的百分号后⾯，加⼊了赋值忽略符 * ，表⽰这个占位符没有对应的变量，解读后不必返回。

6.高质量scanf

应该在输入前有提示.

printf(请输入……"");  
scanf("%d", &a);

如何用scanf编写高质量代码?

1. 使用scanf之前最好先使用printf提示用户以什么样的方式来输入。
2. scanf中尽量不要使用非输入控制符，尤其是不要用'\n'。、 eg: scanf("%d\n", &a); 必须输入"8\n"
3. 应编写代码对用户的非法输入做适当的处理。 处理方法:

char ch;
while('\n' != (ch = getchar()))
{
    continue;
}

例子2:

#include<stdio.h>

int main(void)
{
    int a, c;
    char ch;

    scanf("%d\n", &a);
    printf("%d\n", a);

    while('\n' != (ch = getchar()))
    {
        continue;
    }
        // 加上面代码可解决此问题，功能是把输入的字符全部接收，
        // 也即输入的字符应经被清空，可进行下次输入。
    scanf("%d", &c);
    printf("%d\n", c);
}

若直接输入99m,则a = 99,c = 垃圾值.这是因为a把99m中的99当做有效值接收,而c从m开始接收,出错.scanf中没有被接收的值不会自动清除,而是保留等下个变量再来接收.

注意:scanf函数在遇到空格或换行符时会停止读取.

7.scanf()与数组

int main()
{
    i = 0;
    arr[4] = {0};
    while(i<4)
    {
        scanf("%d",&arr[i]);
        i++;
    }
    return 0;
}

(3)getchar()和putchar()

getchar()和putchar()函数的定义

getchar()和putchar()是一对字符输入/输出函数。getchar()不带任何参数，getchar()用于读取用户从键盘输入的单个字符。putchar()向终端输出一个字符，其格式为putchar()。getchar()和putchar()函数包含在头文件stdio.h中，使用时需包含此头文件。

举例:

#include<stdio.h>
int main()
{
	int ch = getchar();//实际变量ch中放的是读到的那个字符的ASCII码值,键盘输入
	putchar(ch);//putchar接收到一个参数（ASCII码值），输出相对应的字符
	return 0;
}

getchar（）函数为什么用int定义返回值类型

getchar()函数的返回值类型时整形，当发生读取错误时，返回整型值是-1，把一个负值赋给一个char型的变量是不正确的。当读取正确时，他会返回用户从键盘输的第一个字符的ASCII码值，ASCII码值是数字符号，通过这里也可以看出来getchar()返回值类型应用int定义.

函数getchar()和函数scanf()的工作原理

它们的工作原理有相同也有不同
相同之处:
getchar()和scanf()不是直接从键盘上拿数据，他们是从键盘的缓冲区拿数据，键盘输入的字符会放入缓冲区，若用户不按回车键，所有放入缓冲区的字符都不会被读。
不同之处: 在用户按下回车键后，缓冲区内会存在’\n’，scanf只会都'\n'之前的字符，不读' \n'和空格. getchar会将缓冲区的所有字符全部读走，其中包括空格和'\n'。在windows下如果想结束，就输入Ctrl+Z,表示EOF.

以下的代码适当的修改是可以用来清理缓冲区的.

//代码1
#include <stdio.h>
int main()
{
    int ch = 0;
    while ((ch = getchar()) != EOF)//说明得到的是正常的字符
        putchar(ch);
    return 0;//ctrl+Z可以让代码停下来
}

以下的代码用来演示使用getchar()和putchar()实现更加复杂的功能

#include<stdio.h>
int main()
{
	char password[20] = { 0 };
	printf("请输入密码：>");
	scanf("%s", password);
    //注意这里没有取地址`&`,原因是数组的地址已经是在创建的过程中就已经建好了的


    //scanf不是直接从键盘拿数据，scanf的工作原理是：在scanf和键盘之间的输入缓冲区中拿数据，输入缓冲区有数据他就拿，没有他就等，当从键盘上输入字符abcdef为了让字符abcdef来到缓冲区
	//在键盘上输入\n（回车）字符连同\n一起来到缓冲区,scanf会拿走\n之前的字符abcdef缓冲区剩下\n
	//scanf不读空格和回车
	int tmp = 0;
	while ((tmp = getchar()) != '\n')//用来清理缓冲区//注意这种写法((tmp = getchar())
	{
		;//啥也没干,或着加上(continue)
	}
	printf("请确认密码(y/n):"); 
	int ch = getchar();  //getchar和scanf的工作原理一样，他会读走缓冲区里剩余的\n,ch里边是\n
	if (ch == 'y')       //getchar和putchar每次只会输入和输出一个字符
	{
		printf("确认成功\n");
	}
	else
	{
		printf("确认失败\n");
	}
	return 0;
}

以下代码的作用是：只打印数字字符，跳过其他字符的

//代码2
#include <stdio.h>
int main()
{
    char ch = '\0';
    while ((ch = getchar()) != EOF)
    {
        if (ch < '0'|| ch > '9')
            continue;
        putchar(ch);
    }
    return 0;
}

putchar,getchar,scanf和printf区别

putchar和getchar是输入输出单字符的，printf和scanf可以输入多字符，并且getchar和putchar只可以用于字符型的输入输出，而scanf和printf可以用于整型，浮点型和字符型等类型的输入和输出。

注意： putchar()输出指定的字符，不会在输出后自动换行，所以putchar(a)和putchar(b)之间要加putchar('\n')，用作换行.

二、字符串操作函数

1.strlen()的使用和模拟实现

size_t strlen ( const char * str );

• 字符串以 '\0' 作为结束标志，strlen函数返回的是在字符串中 '\0' 前⾯出现的字符个数（不包含 '\0' )。
• 参数指向的字符串必须要以 '\0' 结束。
• 注意函数的返回值为 size_t，是⽆符号的（ 易错 ）
• strlen的使⽤需要包含头⽂件
• 学会strlen函数的模拟实现

#include <stdio.h>
#include <string.h>
int main()
{
    const char* str1 = "abcdef";
    const char* str2 = "bbb";
    if(strlen(str2)-strlen(str1)>0)
    {
        printf("str2>str1\n");
    } 
    else
    {
        printf("srt1>str2\n");
    }
    return 0;
}

strlen的模拟实现：
方式1：

//计数器⽅式
int my_strlen(const char * str)
{
    int count = 0;
    assert(str);
    while(*str)
    {
        count++;
        str++;
    }
    return count;
}

⽅式2：

//不能创建临时变量计数器
int my_strlen(const char * str)
{
    assert(str);
    if(*str == '\0')
        return 0;
    else
        return 1+my_strlen(str+1);
}

方式3：

//指针-指针的⽅式
int my_strlen(char *s)
{
    assert(str);
    char *p = s;
    while(*p != ‘\0’ )
        p++;
    return p-s;
}

2.strcpy()的使用和模拟实现

使用

char* strcpy(char * destination, const char * source );

Copies the C string pointed by source into the array pointed by destination, including theterminating null character (and stopping at that point).

注意：

• 源字符串必须以 '\0' 结束。
• 会将源字符串中的 '\0' 拷⻉到⽬标空间。
• ⽬标空间必须⾜够⼤，以确保能存放源字符串。
• ⽬标空间必须可修改。
• 学会模拟实现。

模拟实现

1. 参数顺序
2. 函数的功能，停止条件
3. assert()
4. const修饰指针
5. 函数返回值
6. 题目出自《高质量C/C++编程》书籍最后的试题部分

char* my_strcpy(char *dest,const char*src)
//这里返回类型是char*，目的是为了实现链式访问
//返回值应该是目标位置的起始地址
{
    char *ret = dest;
    assert(dest != NULL);
    assert(src != NULL);
    while((*dest++ = *src++))
    {
        ;
    }
    return ret;
}

3.strcat()的使用和模拟实现

使用

char *strcat( char *strDestination, const char *strSource );

Appends a copy of the source string to the destination string. The terminating null character in destination is overwritten by the first character of source, and a null-character is included at the end of the new string formed by the concatenation of both in destination.

• 源字符串必须以'\0' 结束。
• 目标字符串中也得有\0 ，否则没办法知道追加从哪里开始。
• 目标空间必须有足够的大，能容纳下源字符串的内容。
• 目标空间必须可修改。
• 字符串自己给自己追加，如何？

模拟实现

#include <stdio.h>
#include <assert.h>

char* my_strcat(char* dest, const char* src)
{
    char* ret = dest;
    assert(dest && src);
    while (*dest )
    {
        dest++;
    }
    while ((*dest++ = *src++))
    {
        ;
    }
    return ret;
}

int main()
{
    char str1[10] = "abc";
    char str2[] = "def";
    my_strcat(str1,str2);
    printf("%s\n",str1);
    return 0;
}

4.strcmp()的使⽤和模拟实现

int strcmp( const char *string1, const char *string2 );

使用 This function starts comparing the first character of each string. If they are equal to each other, it continues with the following pairs until the characters differ or until a terminating null-character is reached.

标准规定：

• 第一个字符串大于第二个字符串，则返回大于0的数字
• 第一个字符串等于第二个字符串，则返回0
• 第一个字符串小于第二个字符串，则返回小于0的数字
• 那么如何判断两个字符串？ 比较两个字符串中对应位置上字符ASCII码值的大小。

模拟实现

int my_strcmp (const char * str1, const char * str2)
{
    int ret = 0 ;
    assert(str1 != NULL);
    assert(str2 != NULL);
    while(*str1 == *str2)
    {
        if(*str1 == '\0')
            return 0;
        str1++;
        str2++;
    }
    return *str1-*str2;
}

5.strncpy()函数的使⽤

char *strncpy( char *strDest, const char *strSource, size_t count );

Copies the first num characters of source to destination. If the end of the source C string (which is signaled by a null-character) is found before num characters have been copied, destination is padded with zeros until a total of num characters have been written to it.

• 拷贝num个字符从源字符串到目标空间。
• 如果源字符串的长度小于num，则拷贝完源字符串之后，在目标的后边追加0，直到num个。

6.strncat()函数的使⽤

char *strncat( char *strDest, const char *strSource, size_t count );

• Appends the first num characters of source to destination, plus a terminating null-character. （将source指向字符串的前num个字符追加到destination指向的字符串末尾，再追加一个\0 字符）。

• If the length of the C string in source is less than num, only the content up to the terminating null-character is copied.（如果source 指向的字符串的长度小于num的时候，只会将字符串中到\0 的内容追加到destination指向的字符串末尾）。

/* strncat example */

#include <stdio.h>
#include <string.h>
int main ()
{
    char str1[20];
    char str2[20];
    strcpy (str1,"To be ");
    strcpy (str2,"or not to be");
    strncat (str1, str2, 6);
    printf("%s\n", str1);
    return 0;
}

7.strncmp()函数的使⽤

int strncmp ( const char * str1, const char * 1 str2, size_t num );

比较str1和str2的前num个字符，如果相等就继续往后比较，最多比较num个字母，如果提前发现不一样，就提前结束，大的字符所在的字符串大于另外一个。如果num个字符都相等，就是相等返回0.

8.strstr()的使⽤和模拟实现

char *strstr( const char *string, const char *strCharSet );

• Returns a pointer to the first occurrence of str2 in str1, or a null pointer if str2 is not part of str1. （函数返回字符串str2在字符串str1中第一次出现的位置）。
• The matching process does not include the terminating null-characters, but it stops there.（字符 串的比较匹配不包含\0 字符，以\0 作为结束标志）。

/* strstr example */
#include <stdio.h>
#include <string.h>
int main ()
{
    char str[] ="This is a simple string";
    char * pch;
    pch = strstr (str,"simple");
    strncpy (pch,"sample",6);
    printf("%s\n", str);
    return 0;
}

strstr的模拟实现：

char * strstr (const char * str1, const char * str2)
{
    char *cp = (char *) str1;
    char *s1, *s2;
    if ( !*str2 )
        return((char *)str1);
    while (*cp)
    {
        s1 = cp;
        s2 = (char *) str2;
        while ( *s1 && *s2 && !(*s1-*s2) )
            s1++, s2++;
        if (!*s2)
            return(cp);
        cp++;
    }
    return(NULL);
}

9.strtok()函数的使用

用于切割字符串

char *strtok( char *strToken, const char *strDelimit );

• sep参数指向一个字符串，定义了用作分隔符的字符集合
• 第一个参数指定一个字符串，它包含了0个或者多个由sep字符串中一个或者多个分隔符分割的标记。
• strtok函数找到str中的下一个标记，并将其用 \0 结尾，返回一个指向这个标记的指针。（注：strtok函数会改变被操作的字符串，所以在使用strtok函数切分的字符串一般都是临时拷贝的内容并且可修改。）
• strtok函数的第一个参数不为NULL ，函数将找到str中第一个标记，strtok函数将保存它在字符串中的位置。
• strtok函数的第一个参数为NULL ，函数将在同一个字符串中被保存的位置开始，查找下一个标记。
• 如果字符串中不存在更多的标记，则返回NULL 指针。

#include <stdio.h>
#include <string.h>
int main()
{
    char arr[] = "192.168.6.111";
    char* sep = ".";
    char* str = NULL;
    for (str = strtok(arr, sep); str != NULL; str = strtok(NULL, sep))
    {
        printf("%s\n", str);
    }    
    return 0;
}

10. strerror()函数的使用

Get a system error message (strerror) or prints a user-supplied error message (_strerror).

char *strerror( int errnum );

strerror 函数可以把参数部分错误码对应的错误信息的字符串地址返回来。在不同的系统和C语言标准库的实现中都规定了一些错误码，一般是放在errno.h 这个头文件中说明的，C语言程序启动的时候就会使用一个全局的变量errno来记录程序的当前错误码，只不过程序启动 的时候errno是0，表示没有错误，当我们在使用标准库中的函数的时候发生了某种错误，就会将对应的错误码，存放在errno中，而一个错误码的数字是整数很难理解是什么意思，所以每一个错误码都是有对应的错误信息的。strerror函数就可以将错误对应的错误信息字符串的地址返回。

#include <errno.h>
#include <string.h>
#include <stdio.h>
//我们打印一下0~10这些错误码对应的信息
int main()
{
    int i = 0;
    for (i = 0; i <= 10; i++) 
    {
        printf("%s\n", strerror(i));
    }
    return 0;
}

结果如下：

No error
Operation not permitted
No such file or directory
No such process
Interrupted function call
Input/output error
No such device or address
Arg list too long
Exec format error
Bad file descriptor
No child processes

举例：

#include <stdio.h>
#include <string.h>
#include <errno.h>
int main ()
{
    FILE * pFile;
    pFile = fopen ("unexist.ent","r");
    if (pFile == NULL)
    printf ("Error opening file unexist.ent: %s\n", strerror(errno));
    return 0;
}

输出：

Error opening file unexist.ent: No such 1 file or directory

也可以了解一下 perror 函数，perror函数相当于一次将上述代码中的第9行完成了，直接将错误信息打印出来。perror函数打印完参数部分的字符串后，再打印一个冒号和一个空格，再打印错误信息。

#include <stdio.h>
#include <string.h>
#include <errno.h>
int main ()
{
    FILE * pFile;
    pFile = fopen ("unexist.ent","r");
    if (pFile == NULL)
        perror("Error opening file unexist.ent");
    return 0;
}

输出：

Error opening file unexist.ent: No such 1 file or directory

三、字符操作函数

1.字符分类函数

C语⾔中有⼀系列的函数是专⻔做字符分类的，也就是⼀个字符是属于什么类型的字符的。

这些函数的使⽤都需要包含⼀个头⽂件是ctype.h

这些函数的使⽤⽅法⾮常类似，我们就讲解⼀个函数的事情，其他的⾮常类似：

int islower ( int c );

islower 是能够判断参数部分的 c 是否是⼩写字⺟的。

通过返回值来说明是否是⼩写字⺟，如果是⼩写字⺟就返回⾮0的整数，如果不是⼩写字⺟，则返回0。

写⼀个代码，将字符串中的⼩写字⺟转⼤写，其他字符不变。

#include <stdio.h>
#include <ctype.h>
int main ()
{
    int i = 0;
    char str[] = "Test String.\n";
    char c;
    while (str[i])
    {
        c = str[i];
        if (islower(c)) 
            c -= 32;
        putchar(c);
        i++;
    }
    return 0;
}

2.字符转换函数

C语⾔提供了2个字符转换函数：

int tolower ( int c ); //将参数传进去的⼤写字⺟转⼩写 
int toupper ( int c ); //将参数传进去的⼩写字⺟转⼤写

上⾯的代码，我们将⼩写转⼤写，是-32完成的效果，有了转换函数，就可以直接使⽤ tolower 函数。

#include <stdio.h>
#include <ctype.h>
int main ()
{
    int i = 0;
    char str[] = "Test String.\n";
    char c;
    while (str[i])
    {
        c = str[i];
        if (islower(c)) 
            c = toupper(c);
        putchar(c);
        i++;
    }
    return 0;
}

四、内存操作函数

1.memcpy使用和模拟实现

void * memcpy ( void * destination, const void * source, 1 size_t num );

• 函数memcpy从source的位置开始向后复制num个字节的数据到destination指向的内存位置。
• 这个函数在遇到'\0' 的时候并不会停下来。
• 如果source和destination有任何的重叠，复制的结果都是未定义的。

#include <stdio.h>
#include <string.h>
int main()
{
    int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
    int arr2[10] = { 0 };
    memcpy(arr2, arr1, 20);
    int i = 0;
    for (i = 0; i < 10; i++)
    {
        printf("%d ", arr2[i]);
    }
    return 0;
}

对于重叠的内存，交给memmove来处理。

memcpy函数的模拟实现:

void * memcpy ( void * dst, const void * src, size_t count)
{
    void * ret = dst;
    assert(dst);
    assert(src);
    /*
    * copy from lower addresses to higher addresses
    */
    while (count--) 
    {
        *(char *)dst = *(char *)src;
        dst = (char *)dst + 1;
        src = (char *)src + 1;
    }
    return(ret);
}

2.memmove使用和模拟实现

void * memmove ( void * destination, const void * source, size_t num );

• 和memcpy的差别就是memmove函数处理的源内存块和目标内存块是可以重叠的。
• 如果源空间和目标空间出现重叠，就得使用memmove函数处理。

#include <stdio.h>
#include <string.h>
int main()
{
    int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
    memmove(arr1+2, arr1, 20);
    int i = 0;
    for (i = 0; i < 10; i++)
    {
        printf("%d ", arr1[i]);
    }
    return 0;
}

输出结果：

1 2 1 2 3 4 5 8 9 10

memmove的模拟实现:

void * memmove ( void * dst, const void * src, size_t count)
{
    void * ret = dst;
    if (dst <= src || (char *)dst >= ((char *)src + count)) {
    /*
     * Non-Overlapping Buffers
     * copy from lower addresses to higher addresses
     */
        while (count--) 
        {
            *(char *)dst = *(char *)src;
            dst = (char *)dst + 1;
            src = (char *)src + 1;
        }
    }
    else {
        /*
         * Overlapping Buffers
         * copy from higher addresses to lower addresses
         */
        dst = (char *)dst + count - 1;
        src = (char *)src + count - 1;
        while (count--) {
            *(char *)dst = *(char *)src;
            dst = (char *)dst - 1;
            src = (char *)src - 1;
        //上面这段代码可以简化为以下代码：
        //while(count--){
        //    *((char*)dst+count)=*((char*)src+count);
        //}
        }
    }
    return(ret);
}

3.memset函数的使用

void * memset ( void * ptr, int value,size_t num );

memset是用来设置内存的，将内存中的值以字节为单位设置成想要的内容。

#include <stdio.h>
#include <string.h>
int main ()
{
    char str[] = "hello world";
    memset (str,'x',6);
    printf(str);
    return 0;
}

输出的结果：

xxxxxxworld

4.memcmp函数的使用

int memcmp ( const void * ptr1, const void * ptr2, size_t num );

• 比较从ptr1和ptr2指针指向的位置开始，向后的num个字节er
• 返回值如下：

#include <stdio.h>
#include <string.h>
int main()
{
    char buffer1[] = "DWgaOtP12df0";
    char buffer2[] = "DWGAOTP12DF0";
    int n;
    n = memcmp(buffer1, buffer2, sizeof(buffer1));
    if (n > 0)
        printf("'%s' is greater than '%s'.\n", buffer1, buffer2);    
    else if (n < 0)
        printf("'%s' is less than '%s'.\n", buffer1, buffer2);
    else
        printf("'%s' is the same as '%s'.\n", buffer1, buffer2);
    return 0;
}

时间/日期函数

数学函数

其他库函数

使用latex输入数学公式

一.上下标的输入

1.基本用法

使用^和_即可

$$a^2+b^3=1$$

注意:各种运算符和命令产生的格式效果都只对其后面大括号内的各字符有效 (若其中只有一个字符则可省略大括号)

$$a^{x+y+z}+b_{ij}=c$$

2.斜体与直立体

注意:英文字母只有在表示变量时(或单一字符的函数名称,如F(x))时才可以使用斜体,其余情况都应使用罗马体(直立体).

在大括号内最前方加上\rm+空格+要输入的字母
或者,在大括号内最前方加上\text+空格+要输入的字母

\rm(roman,罗马体)
\text(文本)

问两者有何不同?

1. text可以显示空格,而rm不能显示空格
2. 如果用text,只会把它后面的第一个字母变成直立体,如果用rm,则会把它后面的全部变成直立体

\text{A B},\rm{A B}
\text A B,\rm A B

如下所示

例如:在表示不同元素时,$x_i,x_j$,其中的$i,j$表示1,2,3,...,n,为变量
而当字母表示特殊含义时,如$x_{\rm i}$此时这个i表示input的含义,为文本
直立体的例子还有

1. e:自然对数的底数,为常量
2. i,j:虚数单位,为常量

\text{i},\text{j}

如下方所示:上面的是公式模式下,默认字母的输出,下面的是直立体输出

二.分式与根式

1.分式的基本用法

使用\frac{}{},前一个大括号里面是分子,后一个大括号里面是分母
如果是单个字符,可以直接用空格去替代,如\frac 1 2
可以嵌套frac,如:\frac{\frac{1}{x+y}+1}{y+1}

\frac{}{}
\frac 1 2 
\frac{\frac{1}{x+y}+1}{y+1}

如下所示

2.加大显示

分子或者分母中的嵌套的分式显示较小,可以通过\dfrac(dispaly-style)
演示

3.根式的基本用法

使用\sqrt(square root,平方根)

平方根\sqrt 2,\sqrt{x+y}\\
n次方根\sqrt[n]{a+b}

如下所示

三.*普通运算符

1.运算符号

+-><(常见)  
\times乘,\cdot点乘,  
\div(**div**ide)除  
\pm(plus-minus)正负号,\mp(minus-plus)负正号  
\ge(greater than or equal,大于等于)  
\le(less than or equal,小于等于)  
\gg远大于,\ll远小于  
\ne(not equal不等于)
\approx(**approx**iamte,约等于)  
\equiv(equivalent,恒等的)
\cap交集,\cup并集  
\in属于,\notin不属于  
\subseteq是...的子集,\subsetneqq是...的真子集  
\varnothing空集
\forall任意,\exists存在,\nexists不存在  
\because,\therefore\

演示:

2.数集符号

\mathbb(blackboard bold)+空格+字母
或者,直接+字母

\mathbb R,\R,\Q,\N,\z_+

如下所示

3.其他符号

点:

\cdots横向三个点  
\vdots竖向三个点  
\ddots斜线三个点(diagonal,对角的)

演示:

一些符号:

\infty(infinity,无穷)  
\partial(偏微分的微元符号)  
\nabla  
\propto(proportional to,正比于)  
\degree(度)

演示:

三角函数:

\sin x,\sec x,\cosh x  
对数:  
\log_2 x,\ln x,\lg x  
极限:  
\lim_{x \to 0} \frac {x}{\sinx}  
注:这些符号都应该是直立体

演示

大型运算符

1.求和和连乘

\sum(求和),\prod(product,乘积)  
\sum_i,\sum_{i=0}^N
\frac{\sum_{i=1}^n x_i}{\prod_{i=1}^n x_i}

演示:

可通过在\sum和\prod后面加上\limits来强制n和i=0到求和符号上下

\frac{\sum_{i=1}^n x_i}{\prod_{i=1}^n x_i}
\frac{\sum\limits_{i=1}^n x_I}{\prod\limits_{i=1}^n x_i}

如下

2.积分的表示:

\int(integral积分)
\iint(双重积分)
\iiint(三重积分)
\oint(回路积分),\oiint(双重回路积分)
\int_{-\infty}^0 f(x)\,\text d x

演示:

3.*插入空格的不同方法

a\,a
a\ a
a\quad a
a\qquad a

标注符号

\vec x,\overrightarrow {AB}(向量)  
\bar x(平均值),\overline{AB}

演示:

箭头

\leftarrow(单箭头)
\rightarrow

希腊字母

重新认识希腊字母

*希腊字母英文对照表*

如何用latex输入希腊字母

反斜杠加上标准的希腊字母英文拼写
大写的希腊字母就把开头第一个字母大写

标准希腊字母英文对照
alpha,beta,gamma,delta,epsilon,zeta,eta,theta,iota,kappa,lambda,mu,nu,xi,omicron(o),pi,rho,sigma,tau,upsilon,phi,chi,psi,omega
其中的omicron可以简写成o,而且前面无需添加斜杠.

小写希腊字母

大写希腊字母

存在变体,如何输入?

\变体就是大写的基础上稍稍斜了点 \在希腊字母英文前面加上var,注意一定要让那个字母英文首字母大写,否则会失效.
\vargamma无效 \varGamma有效

泰勒级数公式是将一个函数在某点处展开成无穷级数的一种表示形式，其一般公式为：

$[f(x)=\sum_{n = 0}^{\infty} \frac{f^{(n)}(x_0)}{n!}(x - x_0)^n]$

其中，(f(x))是要展开的函数，(x_0)是展开的中心点，(f^{(n)}(x_0))是(f(x))在(x_0)处的(n)阶导数，(n!)是(n)的阶乘，((x - x_0)^n)是幂次项。

泰勒级数的展开是基于函数在某点的局部近似，通过不断增加级数的项数，可以提高近似的精度。以下是对该公式的详细解释：

泰勒多项式

泰勒级数的前(n)项和构成了泰勒多项式，它是对原函数的一种近似表示：

$[P_n(x)=\sum_{k = 0}^{n} \frac{f^{(k)}(x_0)}{k!}(x - x_0)^k=f(x_0)+f^{\prime}(x_0)(x - x_0)+\frac{f^{\prime\prime}(x_0)}{2!}(x - x_0)^2+\cdots+\frac{f^{(n)}(x_0)}{n!}(x - x_0)^n]$

余项

泰勒级数中除了前面的(n)项泰勒多项式外，剩余的部分就是余项(R_n(x))，它表示了用泰勒多项式近似原函数时的误差。余项有多种表示形式，常见的有以下几种：

• 佩亚诺余项：$(R_n(x)=o((x - x_0)^n))$ ，它表明余项是比 $((x - x_0)^n)$ 高阶的无穷小量，当$(x\to x_0)$时，$(\lim_{x\to x_0}\frac{R_n(x)}{(x - x_0)^n}=0)$ 。
• 拉格朗日余项：$(R_n(x)=\frac{f^{(n + 1)}(\xi)}{(n + 1)!}(x - x_0)^{n + 1})$，其中(\xi)介于(x_0)与(x)之间。
• 柯西余项：$(R_n(x)=\frac{f^{(n + 1)}(\xi)}{n!}(x - \xi)^n(x - x_0))$ ，(\xi)介于(x_0)与(x)之间 。
• 积分余项：$(R_n(x)=\frac{1}{n!}\int_{x_0}^{x}(x - t)^nf^{(n + 1)}(t)dt)$。

特殊情况：麦克劳林级数

当(x_0 = 0)时，泰勒级数就变成了麦克劳林级数，其公式为：

$[f(x)=\sum_{n = 0}^{\infty} \frac{f^{(n)}(0)}{n!}x^n=f(0)+f^{\prime}(0)x+\frac{f^{\prime\prime}(0)}{2!}x^2+\cdots+\frac{f^{(n)}(0)}{n!}x^n+\cdots]$

以下是一些常见函数的麦克劳林级数展开式：

• 指数函数：$(e^x=\sum_{n = 0}^{\infty} \frac{x^n}{n!}=1+x+\frac{x^2}{2!}+\frac{x^3}{3!}+\cdots+\frac{x^n}{n!}+\cdots)$
• 正弦函数：$(\sin x=\sum_{n = 0}^{\infty} \frac{(-1)^n}{(2n + 1)!}x^{2n + 1}=x-\frac{x^3}{3!}+\frac{x^5}{5!}-\frac{x^7}{7!}+\cdots+\frac{(-1)^n}{(2n + 1)!}x^{2n + 1}+\cdots)$
• 余弦函数：$(\cos x=\sum_{n = 0}^{\infty} \frac{(-1)^n}{(2n)!}x^{2n}=1-\frac{x^2}{2!}+\frac{x^4}{4!}-\frac{x^6}{6!}+\cdots+\frac{(-1)^n}{(2n)!}x^{2n}+\cdots)$
• 自然对数函数：(\ln(1 + x)=\sum_{n = 1}^{\infty} \frac{(-1)^{n - 1}}{n}x^n=x-\frac{x^2}{2}+\frac{x^3}{3}-\frac{x^4}{4}+\cdots+\frac{(-1)^{n - 1}}{n}x^n+\cdots)，((-1&lt;x\leqslant1))
• 幂函数：$((1 + x)^{\alpha}=\sum_{n = 0}^{\infty} \frac{\alpha(\alpha - 1)\cdots(\alpha - n + 1)}{n!}x^n=1+\alpha x+\frac{\alpha(\alpha - 1)}{2!}x^2+\cdots+\frac{\alpha(\alpha - 1)\cdots(\alpha - n + 1)}{n!}x^n+\cdots)$

机器学习

内容与核心

• 监督学习

1. 线性模型
2. 线性和二次判别分析
3. 核岭回归
4. 支持向量机
5. 随机梯度下降
6. 最近邻
7. 高斯过程
8. 交叉分解
9. 朴素贝叶斯
10. 决策树
11. 集成：梯度提升、随机森林、bagging、投票、stacking
12. 多类和多输出算法
13. 特征选择
14. 半监督学习
15. 等渗回归
16. 概率校准
17. 神经网络模型（监督）

• 无监督学习

1. 高斯混合模型
2. 流形学习
3. 聚类
4. 双聚类
5. 信号分解（矩阵分解问题）
6. 协方差估计
7. 新颖性和异常值检测
8. 密度估计
9. 神经网络模型（无监督）

一 监督模型

1.线性模型

• 普通最小二乘法
• 非负最小二乘法
• 普通最小二乘复杂度
• 岭回归和分类
• 套索
• 多任务套索
• 弹性网络
• 多任务弹性网络
• 最小角回归
• LARS 套索
• 正交匹配追踪（OMP）
• 贝叶斯回归
• 逻辑回归
• 广义线性模型
• 随机梯度下降 - SGD
• 感知器
• 被动攻击算法
• 稳健性回归：异常值和建模误差
• 分位数回归
• 多项式回归：利用基函数扩展线性模型

线性模型通过以下方式扩展核心思想：

1. 正则化：控制过拟合（L1/L2正则化）。
2. 优化算法：适应不同场景（闭式解、梯度下降、LARS）。
3. 概率框架：贝叶斯方法引入不确定性。
4. 损失函数：适应不同任务（均方误差、Log损失、Huber损失）。
5. 非线性扩展：多项式回归、基函数扩展（如径向基函数）。

什么是线性模型？

1 机器学习基本概念

机器学习模型分为

• 有监督学习模型
• 无监督学习模型

1.1 有监督学习模型

有监督学习模型主要分为单模型和集成学习两种：

• 单模型使用一个独立算法处理数据来学习和预测。其特点为简单易懂，训练和预测过程透明，计算开销小、训练时间短，且易于调试定位问题。不过，它易受数据噪声和异常值影响。
• 集成学习则结合多个模型提升预测性能，增强鲁棒性。其优势在于能综合各模型长处，性能通常优于单模型，对噪声和异常值耐受性更好。但它也存在不足，实现与调试复杂，需管理多个模型及组合方式，训练和预测消耗更多计算资源与时间。

1.1.1 单模型

• 线性模型：

  • 线性回归：用于建立因变量和自变量之间的线性关系，通过最小化误差平方和来确定模型参数，常用于预测数值型结果。
  • 逻辑回归：虽名字有“回归”，实则用于分类问题，利用对数几率函数将线性回归结果转化为概率值，判断样本所属类别。
  • Lasso：在回归分析中引入L1正则化，可对系数进行压缩，实现特征选择和防止过拟合。
  • Ridge：即岭回归，引入L2正则化，在回归系数估计中加入惩罚项，使系数估计更稳定，降低方差。

• k近邻：基于实例的学习方法，给定测试样本，通过计算与训练集中样本的距离（如欧氏距离），找出k个最近邻样本，根据这些样本的类别（分类问题）或数值（回归问题）来预测测试样本的结果。

• 决策树：

  • ID3：以信息增益为准则选择划分属性构建决策树，每次选择使信息增益最大的属性进行分裂。
  • C5.0：在ID3基础上改进，使用信息增益比，还能处理连续属性和缺失值，可生成规则集。
  • CART：分类回归树，既能用于分类（二叉树，基于基尼指数选择划分属性 ），也能用于回归（基于最小平方误差 ）。

• 神经网络：

  • 感知机：最简单的神经网络模型，由输入层、输出层组成，通过权重调整学习输入和输出的映射关系，可解决线性可分问题。
  • 神经网络：通常指多层感知机，包含多个隐藏层，能学习复杂的非线性映射关系，通过反向传播算法更新权重。

• 支持向量机：

  • 线性可分：在样本线性可分情况下，寻找能最大化样本间隔的超平面进行分类。
  • 线性支持：针对近似线性可分情况，引入松弛变量允许部分样本出错。
  • 线性不可分：通过核函数将样本映射到高维空间，使其线性可分，再寻找最优超平面。

1.1.2 集成学习

• Boosting：
  • GBDT：梯度提升决策树，基于梯度下降思想，每次迭代拟合残差的近似值（负梯度 ），不断构建新决策树来提升模型性能。
  • AdaBoost：通过改变样本权重，让后续弱学习器更关注之前被误分类的样本，迭代训练多个弱学习器并加权组合成强学习器。
  • XGBoost：对GBDT的优化，在目标函数中加入正则项控制模型复杂度，支持并行计算，训练效率高，广泛应用于数据挖掘竞赛等领域。
  • LightGBM：采用直方图算法等优化策略，减少内存占用和计算量，支持更快的并行学习，在处理大规模数据时表现出色。
  • CatBoost：能自动处理类别型特征，采用排序提升算法，减少梯度估计偏差，在准确性和鲁棒性方面有不错表现。
• Bagging：
  • 随机森林：基于Bagging集成学习方法，从原始训练集有放回抽样构建多个子集，每个子集训练一棵决策树，最终通过对多棵树的预测结果进行投票（分类）或平均（回归）得到最终结果，能有效降低方差，防止过拟合。

1.2 无监督学习模型

无监督学习模型中的两个主要类别：聚类和降维。

1.2.1 聚类

• 聚类: 是一种无监督学习技术，用于将数据集中相似的数据点分组。
  • K-means: 一种基于质心的聚类算法，通过迭代优化质心位置以最小化每个点到其所在簇中心的距离。
  • 层次聚类: 创建层次关系的聚类方法，可分为自底向上的聚合层次聚类和自顶向下的分裂层次聚类。
  • 谱聚类: 利用图论、通过计算数据点之间的相似度矩阵以进行聚类的方法。

1.2.2 降维

• 降维: 是无监督学习中的另一种方法，用于减少数据集的特征维数，同时尽量保留数据的主要信息。
  • PCA (主成分分析): 通过线性变换将数据映射到新的坐标系中，新坐标系的轴（主成分）按数据方差大小排序，以保留最大方差信息。
  • SVD (奇异值分解): 一种矩阵因子分解技术，常用于数据降维和压缩。
  • LDA (线性判别分析): 尽管通常用作监督学习，其思路也被用作降维技术，通过最大化类间分隔和最小化类内分布。

1.3 什么是监督学习？什么是非监督学习？

所有的回归算法和分类算法都属于监督学习。并且明确的给给出初始值，在训练集中有特征和标签，并且通过训练获得一个模型，在面对只有特征而没有标签的数据时，能进行预测。

• 监督学习：通过已有的一部分输入数据与输出数据之间的对应关系，生成一个函数，将输入映射到合适的输出，例如 分类。
• 非监督学习：直接对输入数据集进行建模，例如强化学习、K-means 聚类、自编码、受限波尔兹曼机。
• 半监督学习：综合利用有类标的数据和没有类标的数据，来生成合适的分类函数。

1.4 分类，回归和聚类

以下是重新制作的表格，更加清晰有序。您可以根据需要进一步调整格式：

分类	定义	算法	案例
分类	对离散随机变量进行建模预测的监督学习	LR, SVM, KNN, 决策树, 随机森林, GBDT	垃圾邮件分类
回归	对连续随机变量进行建模预测的监督学习	非线性回归, SVR (支持向量回归->可用径向基核 (RBF)), 随机森林	房价预测
聚类	基于数据的内部规律，寻找其属于不同族群的无监督学习	Kmeans, 层次聚类, GMM (高斯混合模型)

1.5 生成模式 vs 判别模式

2.线性模型

2.1 线性回归

原理: 用线性函数拟合数据，用 MSE（均方差） 计算损失，然后用梯度下降法(GD)找到一组使 MSE 最小的权重。

2.1.1 什么是回归？哪些模型可用于解决回归问题？

指分析因变量和自变量之间关系

• 线性回归: 对异常值非常敏感
• 多项式回归: 如果指数选择不当，容易过拟合。
• 岭回归
• Lasso回归
• 弹性网络回归

2.1.2 线性回归的损失函数为什么是均方差?

2.1.3 什么是线性回归？什么时候使用它？

利用最小二乘函数对一个或多个自变量和因变量之间关系进行建模的一种回归分析.

• 自变量与因变量呈直线关系;
• 因变量符合正态分布;
• 因变量数值之间独立;
• 方差是否齐性。

最小二乘和均方误差之间的关系

2.1.4什么是梯度下降？SGD的推导？

2.1.5什么是最小二乘法（最小平方法）？

2.1.6 常见的损失函数有哪些？

1. 0-1损失
2. 均方差损失(MSE)
3. 平均绝对误差(MAE)
4. 分位数损失(Quantile Loss) 分位数回归可以通过给定不同的分位点，拟合目标值的不同分位数；
   实现了分别用不同的系数控制高估和低估的损失，进而实现分位数回归。
5. 交叉熵损失
6. 合页损失 一种二分类损失函数，SVM的损失函数本质： Hinge Loss + L2 正则化
   合页损失的公式如下：

2.1.7 有哪些评估回归模型的指标？

2.1.8 什么是正规方程？

2.1.9 梯度下降法找到的一定是下降最快的方向吗？

不一定，它只是目标函数在当前的点的切平面上下降最快的方向。

在实际执行期中，牛顿方向（考虑海森矩阵）才一般被认为是下降最快的方向，可以达到超线性的收敛速度。梯度下降类的算法的收敛速度一般是线性甚至次线性的（在某些带复杂约束的问题）。

2.2 LR

也称为"对数几率回归"。

1. 分类，经典的二分类算法！
2. LR的过程：面对一个回归或者分类问题，建立代价函数，然后通过优化方法迭代求解出最优的模型参数，然后测试验证这个求解的模型的好坏。
3. Logistic 回归虽然名字里带“回归”，但是它实际上是一种分类方法，主要用于两分类问题（即输出只有两种，分别代表两个类别）
4. 回归模型中，y 是一个定性变量，比如 y = 0 或 1，logistic 方法主要应用于研究某些事件发生的概率。
5. LR的本质：极大似然估计
6. LR的激活函数：Sigmoid
7. LR的代价函数：交叉熵

优点：

1. 速度快，适合二分类问题
2. 简单易于理解，直接看到各个特征的权重
3. 能容易地更新模型吸收新的数据 缺点：
   对数据和场景的适应能力有局限性，不如决策树算法适应性那么强。

LR中最核心的概念是 Sigmoid 函数，Sigmoid函数可以看成LR的激活函数。

Regression 常规步骤：

1. 寻找h函数（即预测函数）
2. 构造J函数（损失函数）
3. 想办法（迭代）使得J函数最小并求得回归参数（θ）

2.2.1 为什么 LR 要使用 sigmoid 函数？

1. 广义模型推导所得
2. 满足统计的最大熵模型
3. 性质优秀，方便使用 （Sigmoid函数是平滑的，而且任意阶可导，一阶二阶导数可以直接由函数值得到不用进行求导，这在实现中很实用）

2.2.2 为什么常常要做特征组合（特征交叉）？

LR模型属于线性模型，线性模型不能很好处理非线性特征，特征组合可以引入非线性特征，提升模型的表达能力。
另外，基本特征可以认为是全局建模，组合特征更加精细，是个性化建模，但对全局建模会对部分样本有偏，对每一个样本建模又会导致数据爆炸，过拟合，所以基本特征+特征组合兼顾了全局和个性化。

2.2.3 LR和线性回归的关系

共同点：

2.2.4 LR参数求解的优化方法？(机器学习中常用的最优化方法)

梯度下降法，随机梯度下降法，牛顿法，拟牛顿法（LBFGS，BFGS,OWLQN）

目的都是求解某个函数的极小值。

2.3 Lasso

2.4 Ridge

2.5 对比

3.验证方式

3.1 什么是过拟合？产生过拟合原因?

指模型在训练集上的效果很好,在测试集上的预测效果很差.

1. 数据有噪声
2. 训练数据不足，有限的训练数据
3. 训练模型过度导致模型非常复杂

3.2 如何避免过拟合问题？

3.3 什么是机器学习的欠拟合？

模型复杂度低或者数据集太小,对模型数据的拟合程度不高,因此模型在训练集上的效果就不好.

3.4 如何避免欠拟合问题？

1. 增加样本的数量
2. 增加样本特征的个数
3. 可以进行特征维度扩展
4. 减少正则化参数
5. 使用集成学习方法，如Bagging

3.5 什么是交叉验证？交叉验证的作用是什么？

将原始dataset划分为两个部分.一部分为训练集用来训练模型,另外一部分作为测试集测试模型效果.

1. 交叉验证是用来评估模型在新的数据集上的预测效果,也可以一定程度上减小模型的过拟合
2. 还可以从有限的数据中获取尽能多的有效信息。

3.6 交叉验证主要有哪几种方法？

1. 留出法:简单地将原始数据集划分为训练集,验证集,测试集三个部分.
2. k折交叉验证:(一般取5折交叉验证或者10折交叉验证)
3. LOO留一法: (只留一个样本作为数据的测试集,其余作为训练集)---只适用于较少的数据集
4. Bootstrap方法:(会引入样本偏差)

3.7 什么是K折交叉验证？

将原始数据集划分为k个子集，将其中一个子集作为验证集，其余k-1个子集作为训练集，如此训练和验证一轮称为一次交叉验证。 交叉验证重复k次，每个子集都做一次验证集，得到k个模型，加权平均k个模型的结果作为评估整体模型的依据。

3.8 如何在K折交叉验证中选择K？

k越大，不一定效果越好，而且越大的k会加大训练时间； 在选择k时，需要考虑最小化数据集之间的方差，比如对于2分类任务，采用2折交叉验证，即将原始数据集对半分，若此时训练集中都是A类别，验证集中都是B类别，则交叉验证效果会非常差。

3.9 网格搜索（GridSearchCV）

一种调优方法，在参数列表中进行穷举搜索，对每种情况进行训练，找到最优的参数。

3.10 随机搜素（RandomizedSearchCV）

从超参数空间中随机采样一定数量的组合进行评估，从中选出表现最好的一组。

3.11 区别

网格搜索（Grid Search）和随机搜索（Random Search）都是超参数调优 的常用方法，用于在机器学习模型中寻找最优的超参数组合。虽然它们的目标相同，但在实现方式、效率、适用场景等方面有明显区别。

4.分类

4.1 几个易混淆的概念

• 准确率（Accuracy）
• 精准率(Precision)
• 召回率(Recall)

准确率是所有判断正确的样本占所有样本的比例；
精确率是所有判断为正例的样本中真正的正例占所有判断为正例的样本的比例；
召回率则是所有正例中被判断出来的比率。

4.2 P-R曲线

横轴为召回率(查全率)，纵轴为精准率(查准率);
引入“平衡点”(BEP)来度量，表示“查准率=查全率”时的取值，值越大表明分类器性能越好。

4.3 F1-Score

准确率和召回率的权衡: 只有在召回率Recall和精确率Precision都高的情况下，F1 score才会很高，比BEP更为常用。

5. 正则化

5.1 什么是正则化？如何理解正则化？

定义: 在损失函数后加上一个正则化项（惩罚项），其实就是常说的结构风险最小化策略，即损失函数 加上正则化。一般模型越复杂，正则化值越大。

正则化项是用来对模型中某些参数进行约束，正则化的一般形式：

第一项是损失函数（经验风险），第二项是正则化项

公式可以看出，加上惩罚项后损失函数的值会增大，要想损失函数最小，惩罚项的值要尽可能的小，模型参数就要尽可能的小，这样就能减小模型参数，使得模型更加简单。

5.2 为何要常对数据做归一化？

1. 归一化后加快的梯度下降对最优解的速度。
2. 归一化有可能提高精度。

5.3 归一化和标准化的区别

标准化是依照特征矩阵的列处理数据，其通过求z-score的方法，将样本的特征值转换到同一量纲下。归一化是依照特征矩阵的行处理数据，其目的在于样本向量在点乘运算或其他核函数计算相似性时，拥有统一的标准，也就是说都转化为“单位向量”。 归一化的目的是方便比较，可以加快网络的收敛速度；标准化是将数据利用z-score（均值、方差）的方法转化为符合特定分布的数据，方便进行下一步处理，不为比较。

5.4 需要归一化的算法有哪些？这些模型需要归一化的主要原因？

线性回归,逻辑回归，KNN，SVM，神经网络。

主要是因为特征值相差很大时，运用梯度下降，损失等高线是椭圆形，需要进行多次迭代才能达到最优点，如果进行归一化了，那么等高线就是圆形的，促使SGD往原点迭代，从而导致需要迭代次数较少。

6. 决策树

6.1 定义

定义： 决策树就是一棵树，其中跟节点和内部节点是输入特征的判定条件，叶子结点就是最终结果。
损失函数：正则化的极大似然函数；
目标是 以损失函数为目标函数的最小化。
算法通常是一个 递归的选择最优特征，并根据该特征对训练数据进行分割，使得对各个子数据集有一个最好的分类过程。
决策树量化纯度：
判断数据集“纯”的指标有三个：Gini指数、熵、错误率

6.2 决策树的数据split原理或者流程？

1. 将所有样本看做一个节点
2. 根据纯度量化指标.计算每一个特征的’纯度’,根据最不’纯’的特征进行数据划分
3. 重复上述步骤,知道每一个叶子节点都足够的’纯’或者达到停止条件

背诵：按照基尼指数、信息增益来选择特征，保证划分后纯度尽可能高。

6.3 构造决策树的步骤？

1. 特征选择
2. 决策树的生成（包含预剪枝） ---- 只考虑局部最优
3. 决策树的剪枝（后剪枝） ---- 只考虑全局最优

6.4 决策树算法中如何避免过拟合和欠拟合？

过拟合:选择能够反映业务逻辑的训练集去产生决策树;
剪枝操作(前置剪枝和后置剪枝); K折交叉验证(K-fold CV) 欠拟合:增加树的深度,RF

6.5 决策树怎么剪枝？

分为预剪枝和后剪枝，预剪枝是在决策树的构建过程中加入限制，比如控制叶子节点最少的样本个数，提前停止；

后剪枝是在决策树构建完成之后，根据加上正则项的结构风险最小化自下向上进行的剪枝操作.

剪枝的目的就是防止过拟合，是模型在测试数据上变现良好，更加鲁棒.

6.6 决策树的优缺点？

决策树的优点：

1. 决策树模型可读性好，具有描述性，有助于人工分析；
2. 效率高，决策树只需要一次性构建，反复使用，每一次预测的最大计算次数不超过决策树的深度。

决策树的缺点：

1. 即使做了预剪枝，它也经常会过拟合，泛化性能很差。
2. 对中间值的缺失敏感；
3. ID3算法计算信息增益时结果偏向数值比较多的特征。

6.7 决策树和条件概率分布的关系？

决策树可以表示成给定条件下类的条件概率分布. 决策树中的每一条路径都对应是划分的一个条件概率分布. 每一个叶子节点都是通过多个条件之后的划分空间，在叶子节点中计算每个类的条件概率，必然会倾向于某一个类，即这个类的概率最大.

7. 神经网络

7.1 核心

1. 核心思想与结构

   • 特征提取机制：通过权重矩阵将输入特征线性组合 $z = w^T x + b$
   • 非线性转换：激活函数（如Sigmoid）生成隐藏层输出 $h = \sigma(z)$
   • 输出计算：
     • 回归任务：$y = v^T h$（线性输出）
     • 分类任务：$y_k = \text{softmax}(v_k^T h) = \frac{e^{v_k^T h}}{\sum e^{v_m^T h}}$

2. 网络拓扑结构

   • 输入层：维度=特征数（如256像素→256节点）
   • 隐藏层：通常1-3层，每层5-100个神经元
   • 输出层：
     • 回归：1个线性神经元
     • K类分类：K个Softmax神经元

7.2 BP反向传播算法

1. 算法流程

   步骤	操作	关键公式
   1	初始化权重	随机小值（如[-0.7, 0.7]）
   2	前向传播	$h_k = \sigma(\sum w_{ih}x_i)$
   3	计算输出误差	$e = \frac{1}{2}\sum(d_o - y_o)^2$
   4	误差反向传播	\delta_o = (d_o - y_o) \sigma'(yi_o)
   5	权重更新	$\Delta w_{ho} = \eta \delta_o h_k$

2. 偏导数计算

   • 输出层：$\delta_o = (d_o - y_o) \cdot y_o(1-y_o)$
   • 隐藏层：$\delta_h = (\sum \delta_o w_{ho}) \cdot h_k(1-h_k)$

3. 误差反向传播（链式法则）

   • 输出层误差：
     $$\delta_o = \frac{\partial E}{\partial z_o} = \begin{cases} (y - \hat{y}) &amp; \text{(回归)} \ (\hat{y} - y) &amp; \text{(分类, cross-entropy)} \end{cases}$$
   • 隐藏层误差：
     \delta_h = \frac{\partial E}{\partial z_h} = (W_{ho}^T \delta_o) \odot \sigma&#39;(z_h)
   • 权重梯度：
     $$\frac{\partial E}{\partial W_{ho}} = h^T \delta_o, \quad \frac{\partial E}{\partial W_{ih}} = X^T \delta_h$$

7.3 训练中的关键问题

1. 权重初始化

   • 策略：小随机数（近零值）
   • 原因：零权重导致梯度消失；大权重收敛到差解

2. 输入标准化

   • 方法：所有输入特征缩放至均值为0、标准差为1
   • 作用：平衡权重更新速度，加速收敛

3. 过拟合控制技术

   • 早停法（Early Stopping）：在验证集误差上升时终止训练
   • 正则化：
     • 权重衰减：$E = \sum(y - \hat{y})^2 + \lambda \sum w_i^2$（L2正则化）
     • Dropout：训练时随机屏蔽50%神经元
   • 数据增强：旋转/平移图像样本（用于ZIP码识别）

4. 局部最小值问题

   问题类型	特征	应对策略
   局部极小值	误差曲面的低谷	多随机初始化（5-10次）
   鞍点	梯度为0的非极小点	动量优化（momentum）

5. 梯度消失问题

   • 原因：Sigmoid导数最大值仅0.25，深层网络梯度连乘后趋近0
   • 解决方案：
     • 使用ReLU激活函数（导数恒为1或0）
     • 残差连接（ResNet）
     • 梯度裁剪（限制梯度范围）

7.4 网络结构设计

1. 隐藏层配置

   数据复杂度	推荐结构	说明
   简单（线性可分）	单隐藏层，5-10神经元	如XOR问题
   中等（手写数字）	1-2隐藏层，12-50神经元	如ZIP编码数据集
   复杂（图像分类）	卷积神经网络+全连接	使用ReLU

2. 权重初始化方法

   • Xavier初始化：$W \sim \mathcal{U}(-\sqrt{\frac{6}{n_{in}+n_{out}}}, \sqrt{\frac{6}{n_{in}+n_{out}}})$
   • He初始化（ReLU适用）：$W \sim \mathcal{N}(0, \sqrt{\frac{2}{n_{in}}})$

3. 超参数调优

   graph TB
   A[学习率η] --> B[网格搜索：0.001, 0.01, 0.1]
   C[正则系数λ] --> D[交叉验证选择]
   E[批量大小] --> F[32/64/128样本/批]
   

组件	推荐策略	注意事项
隐藏层数	1-3层	层数增加提升特征层次性
每层神经元数	5-100个	输入数据复杂时增加单元数
输出层	回归：线性单元 分类：Softmax	二分类可用Sigmoid

---

7.5 案例分析：ZIP编码识别

1. 任务：手写数字识别（0-9）
2. 网络结构（Net-7）
   • 输入：16×16像素图像（256维）
   • 隐藏层：12个神经元（Sigmoid激活）
   • 输出层：10个神经元（Softmax）
3. 性能：
   • 测试错误率：8.2%（优于线性分类器12.2%）
   • 处理机制：非线性分离重叠数字类别

💡 误差曲面特性
平坦区：$\sigma(z) \approx 0$ 或 $1$ → 梯度消失
局部极小：随机初始化+多次训练避免陷入

附：激活函数导数特性
Sigmoid导数：\sigma&#39;(z) = \sigma(z)(1-\sigma(z))

• 最大梯度为0.25（当$z=0$时）
• 输入|z| &gt; 5时梯度接近0 → 参数初始化需避免大权重

考试重点：
① BP算法权重更新公式推导
② 过拟合解决方案对比（早停 vs 正则化）
③ Sigmoid梯度消失原因分析

8. SVM 支持向量机

8.1 支持向量分类器 (Support Vector Classifier or SVC)

8.1.1 最优分类超平面

• 目标：在两类线性可分数据中寻找间隔最大的超平面
  
  $$\min \frac{1}{2} | \mathbf{w} |^2 \quad \text{s.t.} \quad y_i (\mathbf{w}^T \mathbf{x}_i + b) \geq 1$$
• 支持向量：位于间隔边界上的样本点（决定超平面位置）
• 决策函数：$f(\mathbf{x}) = \text{sgn} \left( \sum_{i} \lambda_i y_i \mathbf{x}_i^T \mathbf{x} + b \right)$

8.1.2 软间隔与松弛变量

• 核心问题：处理线性不可分数据（类间重叠）
• 松弛变量 $\xi_i$：允许分类错误
  
  $$\min \frac{1}{2} | \mathbf{w} |^2 + C \sum_{i=1}^N \xi_i \quad \text{s.t.} \quad y_i (\mathbf{w}^T \mathbf{x}_i + b) \geq 1 - \xi_i, \quad \xi_i \geq 0$$
• 参数 $C$：平衡间隔最大化与分类错误惩罚
  • $C \to \infty$：严格分类 → 可能导致过拟合
  • $C \to 0$：容忍错误 → 模型简单但可能欠拟合

8.1.3 拉格朗日对偶问题

• 原始问题 → 对偶形式：
  
  $$\max_{\lambda} \sum_{i=1}^N \lambda_i - \frac{1}{2} \sum_{i,j} \lambda_i \lambda_j y_i y_j \mathbf{x}_i^T \mathbf{x}<em>j$$
  
  
  $$\text{s.t.} \quad \sum</em>{i} \lambda_i y_i = 0, \quad 0 \leq \lambda_i \leq C$$
• KKT条件：$\lambda_i [y_i (\mathbf{w}^T \mathbf{x}_i + b) - 1 + \xi_i] = 0$
• 支持向量判定：\lambda_i &gt; 0 的样本为支持向量

---

8.2 支持向量机与核方法 (SVM with Kernels)

8.2.1 核技巧原理

• 核心思想：将数据映射到高维空间实现线性可分
  
  $$\mathbf{x} \to \phi(\mathbf{x}) \quad \Rightarrow \quad \text{决策函数：} f(\mathbf{x}) = \text{sgn} \left( \sum \lambda_i y_i \color{red}{K(\mathbf{x}_i, \mathbf{x})} + b \right)$$
• 核函数 $K(\mathbf{x}_i, \mathbf{x}_j) = \phi(\mathbf{x}_i)^T \phi(\mathbf{x}_j)$：避免显式计算 $\phi(\mathbf{x})$
• 常用核函数：

  核函数类型	公式	特点
  线性核	$K(\mathbf{x}_i, \mathbf{x}_j) = \mathbf{x}_i^T \mathbf{x}_j$	无参数，适用于线性可分
  多项式核	$(1 + \mathbf{x}_i^T \mathbf{x}_j)^d$	$d$ 控制复杂度
  高斯核 (RBF)	$\exp(-\gamma | \mathbf{x}_i - \mathbf{x}_j |^2)$	$\gamma$ 控制样本影响范围

8.2.2 SVM的惩罚函数视角

• 等价优化问题：
  
  $$\min \sum_{i=1}^N [1 - y_i f(\mathbf{x}<em>i)]</em>+ + \frac{\lambda}{2} | \mathbf{w} |^2$$
  • $[z]_+ = \max(0, z)$：合页损失（Hinge Loss）
  • 本质：L2正则化 + 分类边界惩罚

8.2.3 维度灾难与泛化能力

• 优势：通过核函数在高维隐空间操作 → 避免维度灾难
• 实验结论：SVM在高维数据中比KNN更抗过拟合（见图：Test Error Curves）

---

8.3 支持向量回归 (SVM for Regression)

8.3.1 $\epsilon$-不敏感损失函数

• 核心思想：构造宽度为 $2\epsilon$ 的间隔带包容数据
  
  $$\min \frac{1}{2} | \mathbf{w} |^2 + C \sum_{i=1}^N (\xi_i + \xi_i^<em>)$$
  
  
  $$\text{s.t.} \quad \begin{cases} y_i - (\mathbf{w}^T \phi(\mathbf{x}_i) + b) \leq \epsilon + \xi_i \ (\mathbf{w}^T \phi(\mathbf{x}_i) + b) - y_i \leq \epsilon + \xi_i^</em> \ \xi_i, \xi_i^* \geq 0 \end{cases}$$
• 参数：
  • $\epsilon$：控制回归带宽度（大 $\epsilon$ → 模型简单）
  • $C$：平衡平坦性与误差容忍度

8.3.2 对偶问题

• 回归形式：$f(\mathbf{x}) = \sum_{i} (\lambda_i - \lambda_i^*) K(\mathbf{x}_i, \mathbf{x}) + b$
• 支持向量：|\lambda_i - \lambda_i^*| &gt; 0 的样本（位于间隔带外）

---

IV. 关键对比与考试重点

概念	分类SVM	回归SVM
目标	最大化分类间隔	最小化 $\epsilon$-带外误差
损失函数	合页损失 (Hinge Loss)	$\epsilon$-不敏感损失
支持向量	边界上的点 & 错分点	落在间隔带外的点
参数影响	$C$ 控制分类严格性	$\epsilon$ 控制回归带宽度

重要概念：

1. 必考推导：软间隔SVM对偶问题、KKT条件
2. 核函数选择：高斯核参数 $\gamma$ 的作用（$\gamma \uparrow$ → 模型更复杂）
3. 回归SVM图解：理解 $\xi_i$ 和 $\xi_i^*$ 对应上/下界误差

• 第四章介绍了当两个类别线性可分时的最优分离超平面
• 本章讨论对不可分情况（类别重叠）的扩展
• 支持向量机(SVM)通过在转换后的特征空间构建线性边界来产生非线性边界
• 本章还介绍了Fisher线性判别分析(LDA)的泛化方法：
  • 灵活判别分析：以类似SVM的方式构建非线性边界
  • 惩罚判别分析：用于特征高度相关的信号和图像分类问题
  • 混合判别分析：用于处理形状不规则的类别

9. 聚类分析

9.1 介绍

1. 聚类的本质:

• 将对象分组,使同组内对象相似,不同组间对象不同
• 组内距离(intra-cluster distances)最小化
• 组间距离(inter-cluster distances)最大化

2. 聚类的应用:

• 理解(Understanding):分组相关文档、基因蛋白、股票等
• 总结(Summarization):减少大数据集的规模

3. 聚类的类型:

• 基于划分（Partition-based）：K-means
• 层次聚类（Hierarchical Clustering）：
  • 凝聚层次聚类（AGNES, Bottom-up）：从最细粒度（每个点自成一簇）开始，逐步合并相似的簇。
  • 分裂层次聚类（DIANA, Top-down）：从整体数据（所有点一个簇）开始，逐步拆分不相似的子簇。
• 基于密度（Density-based）：DBSCAN
• 模型基于（Model-based / Mixture Models）：高斯混合模型（Gaussian Mixture Model, GMM）

重要问题：如何求距离？

1. Euclidean Distance（l2 norm） 表达式为 $\sqrt{\sum_{i=1}^{n}(x_{i}-y_{i})^2}$
2. Manhattan Distance（l1 norm） 表达式为 $\sum_{i=1}^{n}|x_{i}-y_{i}|$
3. Minkowski Distance（L-p norm） 表达式为 $\sum_{i=1}^{n}|x_{i}-y_{i}|^{p}$
4. chebyshev Distance（ l-infinity norm） 表达式为 $\max_{i=1}^{n}|x_{i}-y_{i}|$

9.2 基于划分（Partition-based）

代表方法：

• K-means
• 变体k-means++、bi-kmeans、kernel k-means

主要特点：

• 需要事先指定聚类数 $K$。
• 通过迭代式地进行“分配样本到簇”与“更新簇中心点”或“更新样本原型”的过程来收敛。
• 对球状或凸形聚类效果较好，但对于非球状或大小差异较大的簇，效果缺陷明显。
• 适合大规模数据，计算开销相对较低，但对初值和超参数（如K）较敏感。
• 对异常数据比较敏感。

9.2.1 K-means

需要的预设：k和初始中心点

一般来说，初始中心点是随机生成的，且初始中心点的选取对聚类结果影响很大。

• 聚类数目（K）的选择：
  1. elbow方法 ：Elbow方法是基于聚类内部的“紧致度”衡量指标（如簇内平方误差和 $\text{SSE} = \sum_{k=1}^{K} \sum_{\mathbf{x} \in C_k} |\mathbf{x} - \mathbf{\mu}_k |^2$）来评估聚类效果；通常，该指标随着聚类数 $K$ 的增大而减小，但当 $K$ 超过某个合理值时，指标的下降幅度会突然变得缓慢，形成一处明显的“折点”，这就是该方法名称中“肘部（elbow）”的由来。
  2. silhouette方法（轮廓系数法） ： 综合考虑了簇内相似度（凝聚性）和簇间相似度（可分离性）。对于每个样本 $\mathbf{x}_i$，它的轮廓系数 $s(\mathbf{x}_i)$ 定义为
     $$s(\mathbf{x}_i) = \frac{b(\mathbf{x}_i) - a(\mathbf{x}_i)}{\max{a(\mathbf{x}_i),; b(\mathbf{x}_i)}}$$
  • $s(\mathbf{x}_i)$ 的取值在 $[-1, 1]$ 之间：值越接近1，表明该样本与所在簇的距离远小于与其他簇的距离（聚类效果好）。值越接近-1，表明该样本被“分错”簇的可能性很大。

    $a(\mathbf{x}_i)$ 表示该样本与其所在簇中其他样本的平均距离（簇内平均距离）。 $b(\mathbf{x}_i)$ 表示该样本与相邻簇（距离最近的其他簇）中样本的平均距离。

  3. Gap Statistic
  4. Dunn Index

9.2.2 K-means++

k-means++是针对k-means中初始质心点选取的优化算法。

流程如下：

1. 随机选取一个数据点作为初始的聚类中心
2. 当聚类中心数量小于k时：计算每个数据点与当前已有聚类中心的最短距离，用 D(x)表示，这个值越大，表示被选取为下一个聚类中心的概率越大，最后使用轮盘法选取下一个聚类中心

9.2.3 bi-Kmeans

bi-kmeans是针对kmeans算法会陷入局部最优的缺陷进行的改进算法。

流程如下：

1. 将所有点视为一个簇
2. 当簇的个数小于K时对每一个簇计算总误差，在给定的簇上面进行 k-means 聚类（k=2）计算将该簇一分为二之后的总误差
3. 选取使得误差最小的那个簇进行划分操作

9.3 基于密度（Density-based）

k-means算法对于凸性数据具有良好的效果，能够根据距离来讲数据分为球状类的簇，但对于非凸形状的数据点，这个时候就需要用到基于密度的聚类方法了

代表方法：

• DBSCAN
• OPTICS

主要特点：

• 需要提前确定ε和M的值
• 不需要提前设置聚类的个数
• 对初值选取敏感，对噪声不敏感
• 对密度不均的数据聚合效果（DBSCAN不好，OPTICS较好）

9.3.1 DBSCAN

流程如下：

1. 标记所有对象为unvisited
2. 当有标记对象时
   1. 随机选取一个unvisited对象 ( p )
   2. 标记 ( p ) 为visited
   3. 如果 ( p ) 的 ( \varepsilon ) 邻域内至少有 ( M ) 个对象，则
      1. 创建一个新的簇 ( C )，并把 ( p ) 放入 ( C ) 中
      2. 设 ( N ) 是 ( p ) 的 ( \varepsilon ) 邻域内的集合，对 ( N ) 中的每个点 ( p' )
         1. 如果点 ( p' ) 是unvisited
            1. 标记 ( p' ) 为visited
            2. 如果 ( p' ) 的 ( \varepsilon ) 邻域至少有 ( M ) 个对象，则把这些点添加到 ( N )
            3. 如果 ( p' ) 还不是任何簇的成员，则把 ( p' ) 添加到 ( C )
      3. 保存 ( C )
   4. 否则标记 ( p ) 为噪声

DBSCAN算法关键概念:

• ε-邻域:对象半径ε内的区域
• 核心点:ε-邻域内至少包含MinPts个对象的点
• 直接密度可达:从核心点出发能直接到达的点
• 密度可达:通过多个核心点间接到达的点
• 密度相连:两点可从同一点密度可达

9.3.2 OPTICS

在DBSCAN算法中，使用了统一的值，当数据密度不均匀的时候，如果设置了较小的值，则较稀疏的cluster中的节点密度会小于 ，会被认为是边界点而不被用于进一步的扩展；如果设置了较大的 值，则密度较大且离的比较近的cluster容易被划分为同一个cluster。

对于密度不均的数据选取一个合适的是很困难的，对于高维数据，由于维度灾难(Curse of dimensionality),ε的选取将变得更加困难。

9.4 层次聚类（Hierarchical Clustering）

前面介绍的几种算法确实可以在较小的复杂度内获取较好的结果，但是这几种算法却存在一个链式效应的现象，比如：A与B相似，B与C相似，那么在聚类的时候便会将A、B、C聚合到一起，但是如果A与C不相似，就会造成聚类误差，严重的时候这个误差可以一直传递下去。为了降低链式效应，这时候层次聚类就该发挥作用了。

簇间相似度度量：
除了需要衡量对象之间的距离之外，有些聚类算法（如层次聚类）还需要衡量cluster之间的距离

• single linkage：也叫最短距离法，定义两个簇之间的距离为两个簇中距离最近的两个样本点的距离。比如有簇 A 和簇 B，在 A 中找一个点，B 中找一个点，使这两个点距离最短，该距离就是两簇距离。优点是能识别细长形状的簇结构；缺点是易受噪声和离群点影响，可能形成链状聚类结果 。
• complete linkage：又称最长距离法，将两个簇之间的距离定义为两个簇中距离最远的两个样本点的距离。即找出簇 A 和簇 B 中距离最远的一对点，其距离为两簇距离。能产生紧凑的聚类结果，对噪声和离群点相对不敏感，但可能会合并距离较远的簇 。
• average linkage：计算两个簇中所有样本点对之间距离的平均值，以此作为簇间距离。综合考虑了簇内多个样本点的关系，聚类结果相对稳健，能避免单链接和全链接的极端情况 。
• ward linkage：基于方差分析思想，目标是最小化合并簇时增加的簇内离差平方和。每次选择合并使簇内总方差增加最小的两个簇。倾向于产生大小相似的簇，在数据分布较为均匀时效果较好 。

9.4.1 凝聚层次聚类（AGNES, Bottom-up）

称自底向上（bottom-up）的层次聚类，每一个对象最开始都是一个 cluster，每次按一定的准则将最相近的两个 cluster 合并生成一个新的 cluster，如此往复，直至最终所有的对象都属于一个 cluster。这里主要关注此类算法。

过程如下：

1. 初始时每个样本为一个 cluster，计算距离矩阵 D，其中元素$D_{ij}$为样本点$D_{i}$和$D_{j}$之间的距离；
2. 遍历距离矩阵 D，找出其中的最小距离（对角线上的除外），并由此得到拥有最小距离的两个 cluster 的编号，将这两个 cluster 合并为一个新的 cluster 并依据 cluster 距离度量方法更新距离矩阵 D（删除这两个 cluster 对应的行和列，并把由新 cluster 所算出来的距离向量插入 D 中），存储本次合并的相关信息；
3. 重复 2 的过程，直至最终只剩下一个 cluster 。

9.4.2 分割层次聚类（SINGLE, Complete, Average）

又称自顶向下（top-down）的层次聚类，最开始所有的对象均属于一个 cluster，每次按一定的准则将某个 cluster 划分为多个 cluster，如此往复，直至每个对象均是一个 cluster。

9.5 比较总结

算法类型	适合的数据类型	抗噪点性能	聚类形状	算法效率
kmeans	混合型	较差	球形	很高
k-means++	混合型	一般	球形	较高
bi-kmeans	混合型	一般	球形	较高
DBSCAN	数值型	较好	任意形状	一般
OPTICS	数值型	较好	任意形状	一般
Agglomerative	混合型	较好	任意形状	较差

10. 集成学习

10.1 什么是学习器？

广义指代所有通过数据训练得到的预测模型

名称	定义	示例
学习器	广义指代所有通过数据训练得到的预测模型	SVM、决策树、神经网络
基学习器	同质集成中的个体学习器	Bagging中的决策树
弱学习器	性能略优于随机猜测的简单模型（错误率 < 50%）	AdaBoost中的决策树桩
强学习器	高精度模型，或由弱学习器组合而成的集成模型	深度神经网络、XGBoost

学习器的性能受限于：

• 假设空间局限性（如线性模型无法拟合非线性数据）。
• 噪声干扰与过拟合风险。
• 单一模型的表达瓶颈。

解决方案：

• 集成学习：组合多个学习器（如Boosting/Bagging），提升泛化能力。
• 核方法：通过非线性映射扩展学习器的表达能力（如KSVM、KPCA）。

10.2 Boosting和Bagging

集成学习可以分为两种：Boosting和Bagging。

特征	Bagging	Boosting
核心理念	并行生成多个独立模型，降低方差	串行生成依赖模型，逐步修正错误，降低偏差
训练顺序	基学习器独立训练，可并行化	弱学习器顺序训练，必须串行
数据使用	自助采样（Bootstrap） 每个基学习器用不同子集	每轮用全部数据，但调整样本权重
样本权重	所有样本权重相同（均匀采样）	错误样本权重增加（聚焦难例）
基学习器关系	相互独立，无依赖关系	强依赖，后序模型修正前序错误
结合策略	分类：投票法 回归：平均法	加权投票（准确率高的模型权重更大）
目标效果	降低方差 适合高方差模型（如深度决策树）	降低偏差 适合高偏差模型（如树桩）
过拟合风险	不易过拟合（平均抑制噪声）	易过拟合（需控制迭代次数/学习率）
异常值敏感度	不敏感	敏感（错误样本权重持续增加）
代表性算法	随机森林（Random Forest）	AdaBoost, Gradient Boosting, XGBoost
计算效率	高效（可并行）	较低（串行依赖）
噪声鲁棒性	高（平均抑制异常值）	低（异常值权重被放大）
结果稳定性	高（多次运行结果一致）	中（依赖初始样本权重）
超参数调优	简单（通常默认设置即可）	复杂（需调迭代次数/学习率/正则化）

10.2.1 数据采样机制

• Bagging
  • 使用 Bootstrap 抽样：从原始数据集有放回抽取样本（每个基学习器训练集大小 ≈ 原始集，但包含重复样本）。
  • 包外估计 (OOB)：未抽中的样本（约 37%）用于验证模型泛化能力。
• Boosting
  • 全数据集 + 动态权重：每轮迭代调整样本权重，增加分类错误样本的权重。
  • 核心思想：后续模型专注修正前序模型的错误（如 AdaBoost 的加权重训练）。

10.2.2 偏差-方差权衡

• Bagging主要降低方差
  • 场景：适用于复杂模型（如过拟合的决策树），通过平均预测平滑噪声。
  • 示例：随机森林中，若非剪枝树单个错误率 40%，集成 100 棵树后错误率可降至 10% 以下。
• Boosting主要降低偏差
  • 场景：适用于弱模型（如深度=1 的决策树桩），逐步优化训练集拟合。
  • 风险：过度迭代会导致过拟合（见下图迭代次数与错误率关系）。

10.2.3 怎么选

• 选 Bagging 当：

  • 基学习器是高方差模型（如深度决策树、神经网络）。
  • 需要快速并行训练（如大数据场景）。
  • 数据含较多噪声。

• 选 Boosting 当：

  • 基学习器是简单模型（如浅层树）。
  • 追求高精度且可接受较长训练时间。
  • 数据相对干净，需捕捉复杂模式。

二者可结合：如 随机森林 + Gradient Boosting（XGBoost/LightGBM）在竞赛中表现优异。

---

10.3 Boosting方法

10.3.1 核心

1. 核心思想

   • 结合多个弱分类器（错误率略优于随机猜测）构建强分类器。
   • 核心目标：通过加权组合弱分类器提升整体性能。

2. 集成学习基础

   • 个体与集成关系：
     • 集成学习通过结合多个学习器提升性能，要求个体学习器“好而不同”（高准确性和多样性）。
   • 误差分析：
     • 假设基分类器错误率相互独立时，集成错误率随分类器数量增加指数级下降（Hoeffding不等式）。
     • 实际中基学习器存在相关性，需平衡准确性与多样性。

10.3.2 拟合与加法模型

1. 加法模型结构

   • Boosting本质为拟合加法模型：
     
     $$<br>f(x) = \sum_{m=1}^M \beta_m b(x; \gamma_m)$$
     • $b(x; \gamma_m)$ 为基学习器（如决策树桩），$\beta_m$ 为权重系数。
   • 训练策略：前向分步算法（Forward Stagewise Additive Modeling），逐轮添加弱学习器优化目标函数。

2. 前向分步算法流程

   • 初始化：设初始模型 $f_0(x) = 0$。
   • 迭代 $m=1$ 至 $M$：
     1. 优化当前轮次：求解 $\beta_m$ 和 $\gamma_m$ 最小化损失函数（如平方损失、指数损失）。
     2. 更新模型：$f_m(x) = f_{m-1}(x) + \beta_m b(x; \gamma_m)$。

---

10.3.3 AdaBoost

1. AdaBoost算法流程

   • 输入：训练集 $D = {(x_i, y_i)}_{i=1}^N$（$y_i \in {-1, 1}$），基学习器（如树桩）。
   • 初始化权重: $w_i = \frac{1}{N}$.
   • 迭代 $m=1$ 至 $M$：
     1. 训练基分类器 $G_m(x)$ 最小化加权错误率 $\epsilon_m = \sum_{i=1}^N w_i I(y_i \neq G_m(x_i))$.
     2. 计算分类器权重：$\alpha_m = \frac{1}{2} \ln \left( \frac{1-\epsilon_m}{\epsilon_m} \right)$.
     3. 更新样本权重：
        
        $$w_i \leftarrow w_i \cdot \exp \left[ -\alpha_m y_i G_m(x_i) \right], \quad \text{后归一化}.$$
     4. 更新模型：$f(x) = \sum_{m=1}^M \alpha_m G_m(x)$.
   • 输出：$G(x) = \text{sign}[f(x)]$.

2. 指数损失函数

   • 损失函数：$L(y, f(x)) = \exp[-y f(x)]$.
   • 性质：AdaBoost等价于最小化指数损失的前向加法模型。
   • 示例效果：
     • 单树桩测试错误率→45.8%；400轮Boosting后→5.8%。

3. 权重机制

   • 样本权重：错误样本权重增加，正确样本权重减少（聚焦难分类样本）。
   • 分类器权重：准确率高的分类器权重更大（$\alpha_m$ 与 $\epsilon_m$ 负相关）。

---

10.3.4 Boosting Trees

1. 模型形式

   • 基学习器为决策树：
     
     $$f(x) = \sum_{m=1}^M \beta_m T(x; \Theta_m)$$
     • $T(x; \Theta_m)$ 为决策树，$\Theta_m$ 为树参数。

2. 训练策略

   • 递归拟合残差：
     1. 计算当前模型的残差 $r_{i} = y_i - f_{m-1}(x_i)$.
     2. 以残差为目标训练新树 $T_m$.
     3. 更新模型：$f_m(x) = f_{m-1}(x) + T_m(x)$.

---

10.3.5 Gradient Boosting Trees

Gradient Boosting（梯度提升）是一种集成弱学习模型的机器学习方法，例如GBDT就是集成了多个弱决策树模型。

1. 梯度提升框架

   • 核心思想：将优化问题转化为梯度下降。
   • 步骤：
     1. 初始化模型 $f_0(x) = \arg\min_\gamma \sum_{i=1}^N L(y_i, \gamma)$.
     2. 迭代 $m=1$ 至 $M$：
        • 计算伪残差：$r_{im} = -\left[ \frac{\partial L(y_i, f(x_i))}{\partial f(x_i)} \right]<em>{f(x)=f</em>{m-1}(x)}$.
        • 拟合基学习器 $T_m(x)$ 预测伪残差。
        • 更新模型：$f_m(x) = f_{m-1}(x) + \nu \cdot T_m(x)$（$\nu$ 为学习率）。

2. 适用性优点

   • 支持任意可微损失函数（如平方损失、绝对损失）。
   • 学习率 $\nu$ 控制过拟合风险（如 $\nu=0.1$）。

---

10.4 Bagging方法

Bagging 是Bootstrap Aggregating 的缩写，其算法的基本思想是从原始的数据集中抽取数据，形成K个随机的新训练集，然后训练出K个不同的模型。

10.4.1 核心

目标：降低模型方差（Variance），提升泛化能力
方法：通过 Bootstrap 抽样生成多份训练集，并行训练多个基学习器，通过投票（分类） 或 平均（回归） 结合预测结果。

核心公式：

$$\hat{f}<em>{\text{bag}}(x) = \frac{1}{B} \sum</em>{b=1}^{B} \hat{f}^{*b}(x)$$

• $B$：基学习器数量
• $\hat{f}^{*b}$：第 $b$ 个Bootstrap样本训练的基学习器

10.4.2 Bagging流程

Bootstrap自助取样

• 从原始训练集 $D$（大小 $N$）中有放回随机抽取 $N$ 个样本
• 生成 $B$ 个新数据集 $D^{*1}, D^{*2}, \dots, D^{*B}$
• 特性：
  • 每个 $D^{*b}$ 包含约 63.2% 的原始数据（其余为重复样本）
  • 未抽中的样本（Out-of-Bag, OOB）：占比约 36.8%，天然形成验证集（用于评估泛化能力）

并行训练基学习器

• 每个数据集 $D^{*b}$ 独立训练一个基学习器 $\hat{f}^{*b}$（如决策树、SVM等）
• 关键要求：基学习器应为 高方差模型（如未剪枝决策树），Bagging 通过平均降低其方差

集成预测

• 分类任务：多数投票
  
  $$\text{Class}(x) = \arg\max_{c} \sum_{b=1}^{B} I \left( \hat{f}^{*b}(x) = c \right)$$
• 回归任务：简单平均
  
  $$\hat{f}<em>{\text{bag}}(x) = \frac{1}{B} \sum</em>{b=1}^{B} \hat{f}^{*b}(x)$$

10.4.3 数学本质：方差削减原理

设单个基学习器误差方差为 $\sigma^2$，各基学习器误差相关系数为 $\rho$，则 Bagging 集成的方差为：

• 当基学习器完全独立（$\rho = 0$）时：方差降至 $\frac{\sigma^2}{B}$
• 实际中 \rho &gt; 0（学习器相关），但方差仍显著低于单个模型。

示例：
若单棵决策树测试误差率 40%（$\sigma^2 = 0.4$），取 $B = 100$，$\rho = 0.2$：

$$\text{Var} \approx 0.2 \times 0.4 + \frac{0.8}{100} \times 0.4 = 0.0832 \quad (\text{误差率} \approx 28.8$$

10.4.4 Random Forest随机森林

Bagging 的扩展变体，引入双重随机性进一步降方差：

1. 样本随机：Bootstrap 采样
2. 特征随机：每棵树分裂时随机选子集特征（通常 $m = \sqrt{p}$，$p$ 为总特征数）

• 优势：
  • 比标准Bagging方差更低（特征随机降低学习器间相关性 $\rho$）
  • 处理高维数据更有效

多数情况下的Bagging，都是基于决策树的，构造随机森林的第一个步骤其实就是对多棵决策树进行Bagging，我们把它称为树的聚合(Bagging of Tree )。

11. 核方法

11.1 空间与维度

1. 升维与降维的目的

   • 升维：将低维线性不可分问题转化为高维线性可分问题（如通过多项式变换分离非线性数据）。
   • 降维：减少特征维度以降低计算复杂度、消除冗余信息（如PCA保留主要特征方向）。
   • 核心原则：升维解决可分性，降维解决效率与噪声。

2. 示例：一维不可分问题

   • 一维空间中，线性函数无法分离交错的类别（如黑白点混杂）。
   • 解决方案：引入二次判别函数（如 $g(x) = (x-a)(x-b)$）：
     • $g(x) \geq 0$ → 类别 $C_1$；
     • g(x) &lt; 0 → 类别 $C_2$。
   • 本质：通过非线性映射将问题转换到高维空间实现线性可分。

---

11.2 核函数

11.2.1 核函数定义

• 核函数 $K(\mathbf{x}_i, \mathbf{x}_j) = \langle \phi(\mathbf{x}_i), \phi(\mathbf{x}_j) \rangle$ 直接计算高维特征空间的内积，避免显式构造映射 $\phi$。
• 存在条件：Mercer定理要求核矩阵半正定。

11.2.2 常用核类型

• 高斯RBF核：$K(\mathbf{x}, \mathbf{y}) = \exp\left(-\frac{|\mathbf{x}-\mathbf{y}|^2}{c}\right)$
  • 参数 $c$ 控制带宽（$c \uparrow$ → 平滑度 $\uparrow$）。
• 多项式核：$K(\mathbf{x}, \mathbf{y}) = (\theta + \mathbf{x}^T\mathbf{y})^d$
  • $d$ 为多项式阶数，控制复杂度。
• Sigmoidal核：$K(\mathbf{x}, \mathbf{y}) = \tanh(\alpha \mathbf{x}^T\mathbf{y} + \theta)$
  • 模拟神经网络激活函数。
• 逆多元二次核：$K(\mathbf{x}, \mathbf{y}) = \frac{1}{|\mathbf{x}-\mathbf{y}|^2 + c}$

11.2.3 核函数的性质

• 对称性：$K(\mathbf{x}, \mathbf{y}) = K(\mathbf{y}, \mathbf{x})$。
• 正定性：核矩阵 $K_{ij} = K(\mathbf{x}_i, \mathbf{x}_j)$ 半正定。
• 反映数据相似性：值越大表明样本在高维空间越接近。

---

11.3 核K-均值方法

1. 标准K-均值流程

   • Step 1：随机初始化 $K$ 个聚类中心。
   • Step 2：分配样本到最近中心（欧氏距离）。
   • Step 3：重新计算聚类中心（均值）。
   • Step 4：重复直至中心收敛。

2. 核化改进

   • 核心思想：用核函数替代内积，隐式映射到高维空间进行聚类。
   • 距离计算：
     
     $$|\phi(\mathbf{x}) - \phi(\mathbf{c}_k)|^2 = K(\mathbf{x}, \mathbf{x}) - 2K(\mathbf{x}, \mathbf{c}_k) + K(\mathbf{c}_k, \mathbf{c}_k)$$
   • 优势：可分离低维空间中非线性可分的簇（如同心圆数据）。

---

11.4 核支持向量机（KSVM）

1. 非线性SVM的核化

   • 原始目标函数：
     
     $$\max_{\alpha} \sum_{i=1}^n \alpha_i - \frac{1}{2} \sum_{i,j} \alpha_i \alpha_j y_i y_j (\mathbf{x}_i^T \mathbf{x}_j)$$
   • 核化形式：
     
     $$\max_{\alpha} \sum_{i=1}^n \alpha_i - \frac{1}{2} \sum_{i,j} \alpha_i \alpha_j y_i y_j K(\mathbf{x}_i, \mathbf{x}_j)$$

2. 权向量与分类决策

   • 权向量：$\mathbf{w} = \sum_{i} \alpha_i y_i \phi(\mathbf{x}_i)$
   • 决策函数：
     
     $$f(\mathbf{x}) = \text{sign}\left(\sum_{i} \alpha_i y_i K(\mathbf{x}_i, \mathbf{x}) + b\right)$$

3. 示例（二维不可分数据）

   • 数据集：
     • $A = {(1,1), (1,4), (4,1), (4,4)}$（类1）
     • $B = {(2,2), (2,3), (3,2), (3,3)}$（类2）
   • 核函数选择：多项式核 $K(\mathbf{x}, \mathbf{y}) = (1 + \mathbf{x}^T\mathbf{y})^2$ → 实现非线性分离。

---

11.5 核主成分分析（KPCA）

1. **PCA核心思想** - 将数据投影到方差最大的正交方向（主成分）。 - **协方差矩阵**：$\Sigma = \frac{1}{M} \sum \mathbf{x}_i \mathbf{x}_i^T$。 - **特征方程**：$\Sigma \mathbf{v} = \lambda \mathbf{v}$ → $\mathbf{v}$ 为特征向量（投影方向）。

2. KPCA的核化步骤

   • 高维映射：$\mathbf{x} \rightarrow \phi(\mathbf{x})$，要求 $\sum \phi(\mathbf{x}_i) = 0$（中心化）。
   • 核矩阵：$K_{ij} = K(\mathbf{x}_i, \mathbf{x}_j)$。
   • 特征方程：
     
     $$M \lambda \boldsymbol{\alpha} = \mathbf{K} \boldsymbol{\alpha}$$
     • 解 $\boldsymbol{\alpha}$ 得到主成分方向。
   • 投影坐标：第 $k$ 个主成分上样本 $\mathbf{x}$ 的投影：
     
     $$y_k = \sum_{i=1}^M \alpha_i^{(k)} K(\mathbf{x}_i, \mathbf{x})$$

3. KPCA vs PCA

   特性	PCA	KPCA
   空间	原始空间	核映射的高维特征空间
   可分离性	仅线性可分	非线性可分
   计算复杂度	$O(d^3)$	$O(M^3)$（样本驱动）

12. RNN循环神经网络

循环神经网络（Recurrent Neural Network，RNN）是一种具有循环连接的神经网络结构，被广泛应用于自然语言处理、语音识别、时序数据分析等任务中。相较于传统神经网络，RNN的主要特点在于它可以处理序列数据，能够捕捉到序列中的时序信息。

RNN的基本单元是一个循环单元（Recurrent Unit），它接收一个输入和一个来自上一个时间步的隐藏状态，并输出当前时间步的隐藏状态。在传统的RNN中，循环单元通常使用tanh或ReLU等激活函数。

---

12.1 序列建模问题与动机

1. 槽填充任务 (Slot Filling)
   • 目标：从句子中抽取结构化信息（如票务系统中的目的地/时间）
     • 示例输入："leave Taipei on November 2nd" → 输出：离开地=Taipei, 时间=November 2nd
   • 核心挑战：
     • 相同单词（如"Taipei"）在不同上下文含义不同：
       arrive Taipei → 目的地 vs leave Taipei → 出发地
   • 前馈网络缺陷：
     • 无记忆能力，无法捕捉序列依赖（输出仅依赖当前输入）
     • 使用 one-hot 编码（词向量维度=词典大小）丢失上下文信息

---

12.2 RNN 基本结构与原理

1. 核心创新：记忆单元 (Memory)

   graph LR
     A[输入 x_t] --> B[隐藏层 a_t]
     B --> C[输出 y_t]
     B --> D[记忆单元]
     D -->|t+1时刻| B
   

   • 数学表达：
     • $a_t = f(W_{aa}a_{t-1} + W_{ax}x_t + b_a)$ （隐藏状态）
     • $y_t = g(W_{ya}a_t + b_y)$ （输出）
   • 关键特性：
     • 记忆单元存储上一步隐藏状态 $a_{t-1}$
     • 相同网络结构在不同时间步复用

2. 计算示例

   • 参数：所有权重=1，无偏置，线性激活
   • 输入序列：$[1,1] → [1,1] → [2,2]$
   • 输出演化：

     时间步	记忆输入	当前输入	新记忆(a_t)	输出(y_t)
     t=1	[0,0]	[1,1]	[1,1]	[1,1]
     t=2	[1,1]	[1,1]	[1+1+1, 1+1+1]=[3,3]	[3,3]
     t=3	[3,3]	[2,2]	[3+3+2, 3+3+2]=[8,8]	[8,8]

---

12.3 RNN 变体与扩展

12.3.1 网络架构改进

类型	记忆来源	特点
Elman Network	上一步隐藏层 $a_{t-1}$	标准RNN实现
Jordan Network	上一步输出 $y_{t-1}$	减少梯度传播路径

12.3.2 双向RNN (Bi-RNN)

• 结构：

  graph LR
    subgraph 正向
      x1 --> a1 --> y1
      a1 --> a2
      x2 --> a2 --> y2
    end
    subgraph 反向
      x1 --> a1' --> y1
      a1' --> a2'
      x2 --> a2' --> y2
    end
    y1 & y1' --> o1[最终输出t1]
    y2 & y2' --> o2[最终输出t2]
  

• 优势：同时利用过去和未来上下文信息（如语句时序理解）

---

12.4 长短期记忆网络 (LSTM)

12.4.1 解决RNN核心问题

• 长期依赖失效：普通RNN梯度消失导致无法记忆长序列
• 门控机制：通过三扇门控制信息流

12.4.2 LSTM单元结构

graph TB
  x_t & a_t-1 --> ForgetGate
  x_t & a_t-1 --> InputGate
  x_t & a_t-1 --> OutputGate
  x_t & a_t-1 --> NewCandidate
  ForgetGate -->|f_t| CellState-1
  InputGate -->|i_t| NewCandidate
  NewCandidate -->|C_tilde_t| CellStateUpdate
  CellState-1 --> CellStateUpdate
  CellStateUpdate --> CellState_t
  CellState_t --> OutputGate
  OutputGate -->|o_t| a_t

门控计算（$\sigma$为sigmoid）：

• 遗忘门：$f_t = \sigma(W_f \cdot [a_{t-1}, x_t] + b_f)$
• 输入门：$i_t = \sigma(W_i \cdot [a_{t-1}, x_t] + b_i)$
• 候选值：$\tilde{C}<em>t = \tanh(W_C \cdot [a</em>{t-1}, x_t] + b_C)$
• 细胞状态更新：$C_t = f_t \odot C_{t-1} + i_t \odot \tilde{C}_t$
• 输出门：$o_t = \sigma(W_o \cdot [a_{t-1}, x_t] + b_o)$
• 隐藏状态：$a_t = o_t \odot \tanh(C_t)$

12.4.3 LSTM工作原理示例

• 任务：
  • $x_2=1$ 时：将 $x_1$ 值存入记忆
  • $x_3=1$ 时：输出记忆值
  • $x_2=-1$ 时：重置记忆
• 输入序列：$x_1=[3,1,0,0], x_2=[1,0,1,0], x_3=[1,0,0,1]$
  操作结果：记忆值累加→读取→重置

LSTM的优点：

• 通过“加法”而非单纯“乘法”累积记忆，极大缓解了深层或长序列中的梯度消失/爆炸问题。
• 可学习的门控机制，让模型自己决定“还要不要记住”、“要忘掉多少”、“对外输出多少”。

---

12.5 RNN/LSTM 应用场景

1. 自然语言处理
   • 机器翻译（序列到序列建模）
   • 情感分析（时序情感特征提取）
2. 时序数据处理
   • 股票预测（捕捉历史趋势）
   • 传感器异常检测
3. 音频处理
   • 语音识别（声学模型）
   • 音乐生成

---

12.6 关键知识点总结

概念	核心功能	数学工具
记忆单元	存储历史状态	$a_t=f(W_a a_{t-1} + W_x x_t + b)$
双向RNN	同时捕获过去与未来信息	正向+反向隐藏层联合输出
LSTM三门	遗忘门/输入门/输出门控制信息流	Sigmoid门控+Tanh变换
梯度问题解决	细胞状态 $C_t$ 的加法更新避免梯度消失	$C_t = f_t \odot C_{t-1} + i_t \odot \tilde{C}_t$